No OneTemporary
Actions

Size

331 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index bcc34b38f..e146b562c 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,864 +1,864 @@
	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.{Changeset, Query}
	alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
	alias Comeonin.Pbkdf2
	alias Pleroma.Formatter
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.{OStatus, Websub, OAuth}
	alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}

	@type t :: %__MODULE__{}

	schema "users" do
	field(:bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:following, {:array, :string}, default: [])
	field(:ap_id, :string)
	field(:avatar, :map)
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:search_distance, :float, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime)
	has_many(:notifications, Notification)
	embeds_one(:info, Pleroma.User.Info)

	timestamps()
	end

	def avatar_url(user) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> "#{Web.base_url()}/images/avi.png"
	end
	end

	def banner_url(user) do
	case user.info.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> "#{Web.base_url()}/images/banner.png"
	end
	end

	def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
	def profile_url(%User{ap_id: ap_id}), do: ap_id
	def profile_url(_), do: nil

	def ap_id(%User{nickname: nickname}) do
	"#{Web.base_url()}/users/#{nickname}"
	end

	def ap_followers(%User{} = user) do
	"#{ap_id(user)}/followers"
	end

	def follow_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:following])
	\|> validate_required([:following])
	end

	def user_info(%User{} = user) do
	oneself = if user.local, do: 1, else: 0

	%{
	following_count: length(user.following) - oneself,
	note_count: user.info.note_count,
	follower_count: user.info.follower_count,
	locked: user.info.locked,
	default_scope: user.info.default_scope
	}
	end

	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/
	def remote_user_creation(params) do
	params =
	params
	\|> Map.put(:info, params[:info] \|\| %{})

	info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])

	changes =
	%User{}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

	if changes.valid? do
	case info_cng.changes[:source_data] do
	%{"followers" => followers} ->
	changes
	\|> put_change(:follower_address, followers)

	_ ->
	followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})

	changes
	\|> put_change(:follower_address, followers)
	end
	else
	changes
	end
	end

	def update_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:bio, :name, :avatar])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, min: 1, max: 100)
	end

	def upgrade_changeset(struct, params \\ %{}) do
	params =
	params
	\|> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())

	info_cng =
	struct.info
	\|> User.Info.user_upgrade(params[:info])

	struct
	\|> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_embed(:info, info_cng)
	end

	def password_update_changeset(struct, params) do
	changeset =
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)

	OAuth.Token.delete_user_tokens(struct)
	OAuth.Authorization.delete_user_authorizations(struct)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])

	changeset
	\|> put_change(:password_hash, hashed)
	else
	changeset
	end
	end

	def reset_password(user, data) do
	update_and_set_cache(password_update_changeset(user, data))
	end

	def register_changeset(struct, params \\ %{}) do
	changeset =
	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:email, :name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, ~r/^[a-zA-Z\d]+$/)
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)
	\|> put_change(:info, %Pleroma.User.Info{})

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
	ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
	followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})

	changeset
	\|> put_change(:password_hash, hashed)
	\|> put_change(:ap_id, ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

	def needs_update?(%User{local: true}), do: false

	def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	def needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86400
	end

	def needs_update?(_), do: true

	def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
	{:ok, follower}
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	- if !User.ap_enabled?(followed) do
	+ if not User.ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	def maybe_follow(%User{} = follower, %User{info: _info} = followed) do
	if not following?(follower, followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	user_config = Application.get_env(:pleroma, :user)
	deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)

	ap_followers = followed.follower_address

	cond do
	following?(follower, followed) or info.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is already on your list."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	if !followed.local && follower.local && !ap_enabled?(followed) do
	Websub.subscribe(follower, followed)
	end

	following =
	[ap_followers \| follower.following]
	\|> Enum.uniq()

	follower =
	follower
	\|> follow_changeset(%{following: following})
	\|> update_and_set_cache

	{:ok, _} = update_follower_count(followed)

	follower
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	ap_followers = followed.follower_address

	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	following =
	follower.following
	\|> List.delete(ap_followers)

	{:ok, follower} =
	follower
	\|> follow_changeset(%{following: following})
	\|> update_and_set_cache

	{:ok, followed} = update_follower_count(followed)

	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}
	else
	{:error, "Not subscribed!"}
	end
	end

	@spec following?(User.t(), User.t()) :: boolean
	def following?(%User{} = follower, %User{} = followed) do
	Enum.member?(follower.following, followed.follower_address)
	end

	def locked?(%User{} = user) do
	user.info.locked \|\| false
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset) do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
	{:ok, user}
	else
	e -> e
	end
	end

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	Cachex.del(:user_cache, "user_info:#{user.id}")
	end

	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_or_fetch_by_nickname(nickname) end)
	end

	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname)
	end

	def get_by_nickname_or_email(nickname_or_email) do
	case user = Repo.get_by(User, nickname: nickname_or_email) do
	%User{} -> user
	nil -> Repo.get_by(User, email: nickname_or_email)
	end
	end

	def get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
	end

	def fetch_by_nickname(nickname) do
	ap_try = ActivityPub.make_user_from_nickname(nickname)

	case ap_try do
	{:ok, user} -> {:ok, user}
	_ -> OStatus.make_user(nickname)
	end
	end

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	user
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	user
	else
	_e -> nil
	end
	end
	end

	def get_followers_query(%User{id: id, follower_address: follower_address}) do
	from(
	u in User,
	where: fragment("? <@ ?", ^[follower_address], u.following),
	where: u.id != ^id
	)
	end

	def get_followers(user) do
	q = get_followers_query(user)

	{:ok, Repo.all(q)}
	end

	def get_friends_query(%User{id: id, following: following}) do
	from(
	u in User,
	where: u.follower_address in ^following,
	where: u.id != ^id
	)
	end

	def get_friends(user) do
	q = get_friends_query(user)

	{:ok, Repo.all(q)}
	end

	def get_follow_requests_query(%User{} = user) do
	from(
	a in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	a.data
	),
	where:
	fragment(
	"? ->> 'state' = 'pending'",
	a.data
	),
	where:
	fragment(
	"? @> ?",
	a.data,
	^%{"object" => user.ap_id}
	)
	)
	end

	def get_follow_requests(%User{} = user) do
	q = get_follow_requests_query(user)
	reqs = Repo.all(q)

	users =
	Enum.map(reqs, fn req -> req.actor end)
	\|> Enum.uniq()
	\|> Enum.map(fn ap_id -> get_by_ap_id(ap_id) end)
	\|> Enum.filter(fn u -> !following?(u, user) end)

	{:ok, users}
	end

	def increase_note_count(%User{} = user) do
	info_cng = User.Info.add_to_note_count(user.info, 1)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def decrease_note_count(%User{} = user) do
	info_cng = User.Info.add_to_note_count(user.info, -1)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def update_note_count(%User{} = user) do
	note_count_query =
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)

	note_count = Repo.one(note_count_query)

	info_cng = User.Info.set_note_count(user.info, note_count)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def update_follower_count(%User{} = user) do
	follower_count_query =
	from(
	u in User,
	where: ^user.follower_address in u.following,
	where: u.id != ^user.id,
	select: count(u.id)
	)

	follower_count = Repo.one(follower_count_query)

	info_cng =
	user.info
	\|> User.Info.set_follower_count(follower_count)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def get_users_from_set_query(ap_ids, false) do
	from(
	u in User,
	where: u.ap_id in ^ap_ids
	)
	end

	def get_users_from_set_query(ap_ids, true) do
	query = get_users_from_set_query(ap_ids, false)

	from(
	u in query,
	where: u.local == true
	)
	end

	def get_users_from_set(ap_ids, local_only \\ true) do
	get_users_from_set_query(ap_ids, local_only)
	\|> Repo.all()
	end

	def get_recipients_from_activity(%Activity{recipients: to}) do
	query =
	from(
	u in User,
	where: u.ap_id in ^to,
	or_where: fragment("? && ?", u.following, ^to)
	)

	query = from(u in query, where: u.local == true)

	Repo.all(query)
	end

	def search(query, resolve \\ false) do
	# strip the beginning @ off if there is a query
	query = String.trim_leading(query, "@")

	if resolve do
	User.get_or_fetch_by_nickname(query)
	end

	inner =
	from(
	u in User,
	select_merge: %{
	search_distance:
	fragment(
	"? <-> (? \|\| ?)",
	^query,
	u.nickname,
	u.name
	)
	},
	where: not is_nil(u.nickname)
	)

	q =
	from(
	s in subquery(inner),
	order_by: s.search_distance,
	limit: 20
	)

	Repo.all(q)
	end

	def block(blocker, %User{ap_id: ap_id} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	if following?(blocked, blocker) do
	unfollow(blocked, blocker)
	end

	info_cng =
	blocker.info
	\|> User.Info.add_to_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	# helper to handle the block given only an actor's AP id
	def block(blocker, %{ap_id: ap_id}) do
	block(blocker, User.get_by_ap_id(ap_id))
	end

	def unblock(blocker, %{ap_id: ap_id}) do
	info_cng =
	blocker.info
	\|> User.Info.remove_from_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def blocks?(user, %{ap_id: ap_id}) do
	blocks = user.info.blocks
	domain_blocks = user.info.domain_blocks
	%{host: host} = URI.parse(ap_id)

	Enum.member?(blocks, ap_id) \|\|
	Enum.any?(domain_blocks, fn domain ->
	host == domain
	end)
	end

	def block_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.add_to_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def unblock_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.remove_from_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def local_user_query() do
	from(
	u in User,
	where: u.local == true,
	where: not is_nil(u.nickname)
	)
	end

	def moderator_user_query() do
	from(
	u in User,
	where: u.local == true,
	where: fragment("?->'is_moderator' @> 'true'", u.info)
	)
	end

	def deactivate(%User{} = user, status \\ true) do
	info_cng = User.Info.set_activation_status(user.info, status)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def delete(%User{} = user) do
	{:ok, user} = User.deactivate(user)

	# Remove all relationships
	{:ok, followers} = User.get_followers(user)

	followers
	\|> Enum.each(fn follower -> User.unfollow(follower, user) end)

	{:ok, friends} = User.get_friends(user)

	friends
	\|> Enum.each(fn followed -> User.unfollow(user, followed) end)

	query = from(a in Activity, where: a.actor == ^user.ap_id)

	Repo.all(query)
	\|> Enum.each(fn activity ->
	case activity.data["type"] do
	"Create" ->
	ActivityPub.delete(Object.normalize(activity.data["object"]))

	# TODO: Do something with likes, follows, repeats.
	_ ->
	"Doing nothing"
	end
	end)

	{:ok, user}
	end

	def html_filter_policy(%User{info: %{no_rich_text: true}}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: nil

	def get_or_fetch_by_ap_id(ap_id) do
	user = get_by_ap_id(ap_id)

	if !is_nil(user) and !User.needs_update?(user) do
	user
	else
	ap_try = ActivityPub.make_user_from_ap_id(ap_id)

	case ap_try do
	{:ok, user} ->
	user

	_ ->
	case OStatus.make_user(ap_id) do
	{:ok, user} -> user
	_ -> {:error, "Could not fetch by AP id"}
	end
	end
	end
	end

	def get_or_create_instance_user do
	relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"

	if user = get_by_ap_id(relay_uri) do
	user
	else
	changes =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, relay_uri)
	\|> put_change(:nickname, nil)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, relay_uri <> "/followers")

	{:ok, user} = Repo.insert(changes)
	user
	end
	end

	# AP style
	def public_key_from_info(%{
	source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
	}) do
	key =
	- :public_key.pem_decode(public_key_pem)
	+ public_key_pem
	+ \|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	# OStatus Magic Key
	def public_key_from_info(%{magic_key: magic_key}) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

	def get_public_key_for_ap_id(ap_id) do
	with %User{} = user <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key_from_info(user.info) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	defp blank?(""), do: nil
	defp blank?(n), do: n

	def insert_or_update_user(data) do
	data =
	data
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])

	cs = User.remote_user_creation(data)

	Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
	end

	def ap_enabled?(%User{local: true}), do: true
	def ap_enabled?(%User{info: info}), do: info.ap_enabled
	def ap_enabled?(_), do: false

	- def get_or_fetch(uri_or_nickname) do
	- if String.starts_with?(uri_or_nickname, "http") do
	- get_or_fetch_by_ap_id(uri_or_nickname)
	- else
	- get_or_fetch_by_nickname(uri_or_nickname)
	- end
	- end
	+ @doc "Gets or fetch a user by uri or nickname."
	+ @spec get_or_fetch(String.t()) :: User.t()
	+ def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	+ def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- Repo.get(User, a.id),
	%User{} = b <- Repo.get(User, b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- Repo.get(User, a.id),
	%User{} = b <- Repo.get(User, b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

	def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
	def parse_bio(nil, _user), do: ""
	def parse_bio(bio, _user) when bio == "", do: bio

	def parse_bio(bio, user) do
	mentions = Formatter.parse_mentions(bio)
	tags = Formatter.parse_tags(bio)

	emoji =
	(user.info.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	- CommonUtils.format_input(bio, mentions, tags, "text/plain") \|> Formatter.emojify(emoji)
	+ bio
	+ \|> CommonUtils.format_input(mentions, tags, "text/plain")
	+ \|> Formatter.emojify(emoji)
	end

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(User.get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq(user.tags ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(User.get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags), do: update_tags(user, user.tags -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> Repo.update()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase(&1))
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 8f2625cef..ce0926b99 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,249 +1,250 @@
	defmodule Pleroma.Web.CommonAPI.Utils do
	- alias Pleroma.{Repo, Object, Formatter, Activity}
	+ alias Calendar.Strftime
	+ alias Comeonin.Pbkdf2
	+ alias Pleroma.{Activity, Formatter, Object, Repo}
	+ alias Pleroma.User
	+ alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy
	- alias Pleroma.User
	- alias Calendar.Strftime
	- alias Comeonin.Pbkdf2

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity = Repo.get(Activity, id) \|\| Activity.get_create_activity_by_object_ap_id(id)

	activity &&
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	end
	end

	def get_replied_to_activity(""), do: nil

	def get_replied_to_activity(id) when not is_nil(id) do
	Repo.get(Activity, id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = ["https://www.w3.org/ns/activitystreams#Public" \| mentioned_users]
	cc = [user.follower_address]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = [user.follower_address \| mentioned_users]
	cc = ["https://www.w3.org/ns/activitystreams#Public"]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def make_content_html(
	status,
	mentions,
	attachments,
	tags,
	content_type,
	no_attachment_links \\ false
	) do
	status
	\|> format_input(mentions, tags, content_type)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	end

	def make_context(%Activity{data: %{"context" => context}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	def maybe_add_attachments(text, _attachments, _no_links = true), do: text

	def maybe_add_attachments(text, attachments, _no_links) do
	add_attachments(text, attachments)
	end

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} = attachment ->
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

	def format_input(text, mentions, tags, "text/plain") do
	text
	\|> Formatter.html_escape("text/plain")
	\|> String.replace(~r/\r?\n/, "<br>")
	\|> (&{[], &1}).()
	\|> Formatter.add_links()
	\|> Formatter.add_user_links(mentions)
	\|> Formatter.add_hashtag_links(tags)
	\|> Formatter.finalize()
	end

	def format_input(text, mentions, _tags, "text/html") do
	text
	\|> Formatter.html_escape("text/html")
	\|> String.replace(~r/\r?\n/, "<br>")
	\|> (&{[], &1}).()
	\|> Formatter.add_user_links(mentions)
	\|> Formatter.finalize()
	end

	def format_input(text, mentions, tags, "text/markdown") do
	text
	\|> Earmark.as_html!()
	\|> Formatter.html_escape("text/html")
	\|> String.replace(~r/\r?\n/, "")
	\|> (&{[], &1}).()
	\|> Formatter.add_user_links(mentions)
	\|> Formatter.add_hashtag_links(tags)
	\|> Formatter.finalize()
	end

	def add_tag_links(text, tags) do
	tags =
	tags
	\|> Enum.sort_by(fn {tag, _} -> -String.length(tag) end)

	Enum.reduce(tags, text, fn {full, tag}, text ->
	- url = "<a href='#{Pleroma.Web.base_url()}/tag/#{tag}' rel='tag'>##{tag}</a>"
	+ url = "<a href='#{Web.base_url()}/tag/#{tag}' rel='tag'>##{tag}</a>"
	String.replace(text, full, url)
	end)
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	inReplyTo,
	tags,
	cw \\ nil,
	cc \\ []
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end) \|> Enum.uniq()
	}

	if inReplyTo do
	object
	\|> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
	\|> Map.put("inReplyToStatusId", inReplyTo.id)
	else
	object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) do
	with {:ok, date, _offset} <- date \|> DateTime.from_iso8601() do
	format_asctime(date)
	else
	_e ->
	""
	end
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end

	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- Repo.get(User, user.id),
	true <- Pbkdf2.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, "Invalid password."}
	end
	end

	def emoji_from_profile(%{info: _info} = user) do
	(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
	\|> Enum.map(fn {shortcode, url} ->
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
	"name" => ":#{shortcode}:"
	}
	end)
	end
	end
	diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
	index 0e2cfddd0..b67b1333f 100644
	--- a/lib/pleroma/web/salmon/salmon.ex
	+++ b/lib/pleroma/web/salmon/salmon.ex
	@@ -1,209 +1,209 @@
	defmodule Pleroma.Web.Salmon do
	@httpoison Application.get_env(:pleroma, :httpoison)

	use Bitwise
	alias Pleroma.Web.XML
	alias Pleroma.Web.OStatus.ActivityRepresenter
	alias Pleroma.User
	require Logger

	def decode(salmon) do
	doc = XML.parse_document(salmon)

	{:xmlObj, :string, data} = :xmerl_xpath.string('string(//me:data[1])', doc)
	{:xmlObj, :string, sig} = :xmerl_xpath.string('string(//me:sig[1])', doc)
	{:xmlObj, :string, alg} = :xmerl_xpath.string('string(//me:alg[1])', doc)
	{:xmlObj, :string, encoding} = :xmerl_xpath.string('string(//me:encoding[1])', doc)
	{:xmlObj, :string, type} = :xmerl_xpath.string('string(//me:data[1]/@type)', doc)

	{:ok, data} = Base.url_decode64(to_string(data), ignore: :whitespace)
	{:ok, sig} = Base.url_decode64(to_string(sig), ignore: :whitespace)
	alg = to_string(alg)
	encoding = to_string(encoding)
	type = to_string(type)

	[data, type, encoding, alg, sig]
	end

	def fetch_magic_key(salmon) do
	with [data, _, _, _, _] <- decode(salmon),
	doc <- XML.parse_document(data),
	uri when not is_nil(uri) <- XML.string_from_xpath("/entry/author[1]/uri", doc),
	{:ok, public_key} <- User.get_public_key_for_ap_id(uri),
	magic_key <- encode_key(public_key) do
	{:ok, magic_key}
	end
	end

	def decode_and_validate(magickey, salmon) do
	[data, type, encoding, alg, sig] = decode(salmon)

	signed_text =
	[data, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	key = decode_key(magickey)

	verify = :public_key.verify(signed_text, :sha256, sig, key)

	if verify do
	{:ok, data}
	else
	:error
	end
	end

	def decode_key("RSA." <> magickey) do
	make_integer = fn bin ->
	list = :erlang.binary_to_list(bin)
	Enum.reduce(list, 0, fn el, acc -> acc <<< 8 \|\|\| el end)
	end

	[modulus, exponent] =
	magickey
	\|> String.split(".")
	\|> Enum.map(fn n -> Base.url_decode64!(n, padding: false) end)
	\|> Enum.map(make_integer)

	{:RSAPublicKey, modulus, exponent}
	end

	def encode_key({:RSAPublicKey, modulus, exponent}) do
	modulus_enc = :binary.encode_unsigned(modulus) \|> Base.url_encode64()
	exponent_enc = :binary.encode_unsigned(exponent) \|> Base.url_encode64()

	"RSA.#{modulus_enc}.#{exponent_enc}"
	end

	# Native generation of RSA keys is only available since OTP 20+ and in default build conditions
	# We try at compile time to generate natively an RSA key otherwise we fallback on the old way.
	try do
	_ = :public_key.generate_key({:rsa, 2048, 65537})

	def generate_rsa_pem do
	key = :public_key.generate_key({:rsa, 2048, 65537})
	entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
	pem = :public_key.pem_encode([entry]) \|> String.trim_trailing()
	{:ok, pem}
	end
	rescue
	_ ->
	def generate_rsa_pem do
	port = Port.open({:spawn, "openssl genrsa"}, [:binary])

	{:ok, pem} =
	receive do
	{^port, {:data, pem}} -> {:ok, pem}
	end

	Port.close(port)

	if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
	{:ok, pem}
	else
	:error
	end
	end
	end

	def keys_from_pem(pem) do
	[private_key_code] = :public_key.pem_decode(pem)
	private_key = :public_key.pem_entry_decode(private_key_code)
	{:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
	public_key = {:RSAPublicKey, modulus, exponent}
	{:ok, private_key, public_key}
	end

	def encode(private_key, doc) do
	type = "application/atom+xml"
	encoding = "base64url"
	alg = "RSA-SHA256"

	signed_text =
	[doc, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	signature =
	signed_text
	\|> :public_key.sign(:sha256, private_key)
	\|> to_string
	\|> Base.url_encode64()

	doc_base64 =
	doc
	\|> Base.url_encode64()

	# Don't need proper xml building, these strings are safe to leave unescaped
	salmon = """
	<?xml version="1.0" encoding="UTF-8"?>
	<me:env xmlns:me="http://salmon-protocol.org/ns/magic-env">
	<me:data type="application/atom+xml">#{doc_base64}</me:data>
	<me:encoding>#{encoding}</me:encoding>
	<me:alg>#{alg}</me:alg>
	<me:sig>#{signature}</me:sig>
	</me:env>
	"""

	{:ok, salmon}
	end

	def remote_users(%{data: %{"to" => to} = data}) do
	to = to ++ (data["cc"] \|\| [])

	to
	\|> Enum.map(fn id -> User.get_cached_by_ap_id(id) end)
	\|> Enum.filter(fn user -> user && !user.local end)
	end

	defp send_to_user(%{info: %{salmon: salmon}}, feed, poster) do
	with {:ok, %{status: code}} <-
	poster.(
	salmon,
	feed,
	[{"Content-Type", "application/magic-envelope+xml"}]
	) do
	Logger.debug(fn -> "Pushed to #{salmon}, code #{code}" end)
	else
	e -> Logger.debug(fn -> "Pushing Salmon to #{salmon} failed, #{inspect(e)}" end)
	end
	end

	defp send_to_user(_, _, _), do: nil

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]
	- def publish(user, activity, poster \\ &@httpoison.post/4)
	+ def publish(user, activity, poster \\ &@httpoison.post/3)

	def publish(%{info: %{keys: keys}} = user, %{data: %{"type" => type}} = activity, poster)
	when type in @supported_activities do
	feed = ActivityRepresenter.to_simple_form(activity, user, true)

	if feed do
	feed =
	ActivityRepresenter.wrap_with_entry(feed)
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	{:ok, private, _} = keys_from_pem(keys)
	{:ok, feed} = encode(private, feed)

	remote_users(activity)
	\|> Enum.each(fn remote_user ->
	Task.start(fn ->
	Logger.debug(fn -> "Sending Salmon to #{remote_user.ap_id}" end)
	send_to_user(remote_user, feed, poster)
	end)
	end)
	end
	end

	def publish(%{id: id}, _, _), do: Logger.debug(fn -> "Keys missing for user #{id}" end)
	end
	diff --git a/lib/pleroma/web/web_finger/web_finger.ex b/lib/pleroma/web/web_finger/web_finger.ex
	index 0ff3b8b5f..47c733da2 100644
	--- a/lib/pleroma/web/web_finger/web_finger.ex
	+++ b/lib/pleroma/web/web_finger/web_finger.ex
	@@ -1,281 +1,280 @@
	defmodule Pleroma.Web.WebFinger do
	@httpoison Application.get_env(:pleroma, :httpoison)

	alias Pleroma.{User, XmlBuilder}
	alias Pleroma.Web
	alias Pleroma.Web.{XML, Salmon, OStatus}
	require Jason
	require Logger

	def host_meta do
	base_url = Web.base_url()

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	{
	:Link,
	%{
	rel: "lrdd",
	type: "application/xrd+xml",
	template: "#{base_url}/.well-known/webfinger?resource={uri}"
	}
	}
	}
	\|> XmlBuilder.to_doc()
	end

	def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
	host = Pleroma.Web.Endpoint.host()
	regex = ~r/(acct:)?(?<username>\w+)@#{host}/

	with %{"username" => username} <- Regex.named_captures(regex, resource),
	%User{} = user <- User.get_by_nickname(username) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	with %User{} = user <- User.get_cached_by_ap_id(resource) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end

	def represent_user(user, "JSON") do
	{:ok, user} = ensure_keys_present(user)
	{:ok, _private, public} = Salmon.keys_from_pem(user.info.keys)
	magic_key = Salmon.encode_key(public)

	%{
	"subject" => "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}",
	"aliases" => [user.ap_id],
	"links" => [
	%{
	"rel" => "http://schemas.google.com/g/2010#updates-from",
	"type" => "application/atom+xml",
	"href" => OStatus.feed_path(user)
	},
	%{
	"rel" => "http://webfinger.net/rel/profile-page",
	"type" => "text/html",
	"href" => user.ap_id
	},
	%{"rel" => "salmon", "href" => OStatus.salmon_path(user)},
	%{
	"rel" => "magic-public-key",
	"href" => "data:application/magic-public-key,#{magic_key}"
	},
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => OStatus.remote_follow_path()
	}
	]
	}
	end

	def represent_user(user, "XML") do
	{:ok, user} = ensure_keys_present(user)
	{:ok, _private, public} = Salmon.keys_from_pem(user.info.keys)
	magic_key = Salmon.encode_key(public)

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	[
	{:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}"},
	{:Alias, user.ap_id},
	{:Link,
	%{
	rel: "http://schemas.google.com/g/2010#updates-from",
	type: "application/atom+xml",
	href: OStatus.feed_path(user)
	}},
	{:Link,
	%{rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: user.ap_id}},
	{:Link, %{rel: "salmon", href: OStatus.salmon_path(user)}},
	{:Link,
	%{rel: "magic-public-key", href: "data:application/magic-public-key,#{magic_key}"}},
	{:Link, %{rel: "self", type: "application/activity+json", href: user.ap_id}},
	{:Link,
	%{rel: "http://ostatus.org/schema/1.0/subscribe", template: OStatus.remote_follow_path()}}
	]
	}
	\|> XmlBuilder.to_doc()
	end

	# This seems a better fit in Salmon
	def ensure_keys_present(user) do
	info = user.info

	if info.keys do
	{:ok, user}
	else
	{:ok, pem} = Salmon.generate_rsa_pem()

	info_cng =
	info
	\|> Pleroma.User.Info.set_keys(pem)

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

	User.update_and_set_cache(cng)
	end
	end

	defp get_magic_key(magic_key) do
	"data:application/magic-public-key," <> magic_key = magic_key
	{:ok, magic_key}
	rescue
	MatchError -> {:error, "Missing magic key data."}
	end

	defp webfinger_from_xml(doc) do
	with magic_key <- XML.string_from_xpath(~s{//Link[@rel="magic-public-key"]/@href}, doc),
	{:ok, magic_key} <- get_magic_key(magic_key),
	topic <-
	XML.string_from_xpath(
	~s{//Link[@rel="http://schemas.google.com/g/2010#updates-from"]/@href},
	doc
	),
	subject <- XML.string_from_xpath("//Subject", doc),
	salmon <- XML.string_from_xpath(~s{//Link[@rel="salmon"]/@href}, doc),
	subscribe_address <-
	XML.string_from_xpath(
	~s{//Link[@rel="http://ostatus.org/schema/1.0/subscribe"]/@template},
	doc
	),
	ap_id <-
	XML.string_from_xpath(
	~s{//Link[@rel="self" and @type="application/activity+json"]/@href},
	doc
	) do
	data = %{
	"magic_key" => magic_key,
	"topic" => topic,
	"subject" => subject,
	"salmon" => salmon,
	"subscribe_address" => subscribe_address,
	"ap_id" => ap_id
	}

	{:ok, data}
	else
	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	defp webfinger_from_json(doc) do
	data =
	Enum.reduce(doc["links"], %{"subject" => doc["subject"]}, fn link, data ->
	case {link["type"], link["rel"]} do
	{"application/activity+json", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{_, "magic-public-key"} ->
	"data:application/magic-public-key," <> magic_key = link["href"]
	Map.put(data, "magic_key", magic_key)

	{"application/atom+xml", "http://schemas.google.com/g/2010#updates-from"} ->
	Map.put(data, "topic", link["href"])

	{_, "salmon"} ->
	Map.put(data, "salmon", link["href"])

	{_, "http://ostatus.org/schema/1.0/subscribe"} ->
	Map.put(data, "subscribe_address", link["template"])

	_ ->
	Logger.debug("Unhandled type: #{inspect(link["type"])}")
	data
	end
	end)

	{:ok, data}
	end

	def get_template_from_xml(body) do
	xpath = "//Link[@rel='lrdd']/@template"

	with doc when doc != :error <- XML.parse_document(body),
	template when template != nil <- XML.string_from_xpath(xpath, doc) do
	{:ok, template}
	end
	end

	def find_lrdd_template(domain) do
	with {:ok, %{status: status, body: body}} when status in 200..299 <-
	@httpoison.get("http://#{domain}/.well-known/host-meta", []) do
	get_template_from_xml(body)
	else
	_ ->
	with {:ok, %{body: body}} <- @httpoison.get("https://#{domain}/.well-known/host-meta", []) do
	get_template_from_xml(body)
	else
	e -> {:error, "Can't find LRDD template: #{inspect(e)}"}
	end
	end
	end

	def finger(account) do
	account = String.trim_leading(account, "@")

	domain =
	with [_name, domain] <- String.split(account, "@") do
	domain
	else
	_e ->
	URI.parse(account).host
	end

	address =
	case find_lrdd_template(domain) do
	{:ok, template} ->
	String.replace(template, "{uri}", URI.encode(account))

	_ ->
	"https://#{domain}/.well-known/webfinger?resource=acct:#{account}"
	end

	with response <-
	@httpoison.get(
	address,
	- [Accept: "application/xrd+xml,application/jrd+json"],
	- follow_redirect: true
	+ Accept: "application/xrd+xml,application/jrd+json"
	),
	{:ok, %{status: status, body: body}} when status in 200..299 <- response do
	doc = XML.parse_document(body)

	if doc != :error do
	webfinger_from_xml(doc)
	else
	with {:ok, doc} <- Jason.decode(body) do
	webfinger_from_json(doc)
	else
	{:error, e} -> e
	end
	end
	else
	e ->
	Logger.debug(fn -> "Couldn't finger #{account}" end)
	Logger.debug(fn -> inspect(e) end)
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/xml/xml.ex b/lib/pleroma/web/xml/xml.ex
	index 63d3302e0..b3ccf4a55 100644
	--- a/lib/pleroma/web/xml/xml.ex
	+++ b/lib/pleroma/web/xml/xml.ex
	@@ -1,41 +1,41 @@
	defmodule Pleroma.Web.XML do
	require Logger

	def string_from_xpath(_, :error), do: nil

	def string_from_xpath(xpath, doc) do
	try do
	{:xmlObj, :string, res} = :xmerl_xpath.string('string(#{xpath})', doc)

	res =
	res
	\|> to_string
	\|> String.trim()

	if res == "", do: nil, else: res
	catch
	_e ->
	Logger.debug("Couldn't find xpath #{xpath} in XML doc")
	nil
	end
	end

	def parse_document(text) do
	try do
	{doc, _rest} =
	text
	\|> :binary.bin_to_list()
	- \|> :xmerl_scan.string()
	+ \|> :xmerl_scan.string(quiet: true)

	doc
	rescue
	_e ->
	Logger.debug("Couldn't parse XML: #{inspect(text)}")
	:error
	catch
	:exit, _error ->
	Logger.debug("Couldn't parse XML: #{inspect(text)}")
	:error
	end
	end
	end
	diff --git a/test/filter_test.exs b/test/filter_test.exs
	index 509c15317..2b31bcc08 100644
	--- a/test/filter_test.exs
	+++ b/test/filter_test.exs
	@@ -1,154 +1,153 @@
	defmodule Pleroma.FilterTest do
	- alias Pleroma.{User, Repo}
	+ alias Pleroma.Repo
	use Pleroma.DataCase

	import Pleroma.Factory
	- import Ecto.Query

	describe "creating filters" do
	test "creating one filter" do
	user = insert(:user)

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

	{:ok, %Pleroma.Filter{} = filter} = Pleroma.Filter.create(query)
	result = Pleroma.Filter.get(filter.filter_id, user)
	assert query.phrase == result.phrase
	end

	test "creating one filter without a pre-defined filter_id" do
	user = insert(:user)

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

	{:ok, %Pleroma.Filter{} = filter} = Pleroma.Filter.create(query)
	# Should start at 1
	assert filter.filter_id == 1
	end

	test "creating additional filters uses previous highest filter_id + 1" do
	user = insert(:user)

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

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

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

	{:ok, %Pleroma.Filter{} = filter_two} = Pleroma.Filter.create(query_two)
	assert filter_two.filter_id == filter_one.filter_id + 1
	end

	test "filter_id is unique per user" do
	user_one = insert(:user)
	user_two = insert(:user)

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

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

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

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

	assert filter_one.filter_id == 1
	assert filter_two.filter_id == 1

	result_one = Pleroma.Filter.get(filter_one.filter_id, user_one)
	assert result_one.phrase == filter_one.phrase

	result_two = Pleroma.Filter.get(filter_two.filter_id, user_two)
	assert result_two.phrase == filter_two.phrase
	end
	end

	test "deleting a filter" do
	user = insert(:user)

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

	- {:ok, filter} = Pleroma.Filter.create(query)
	+ {:ok, _filter} = Pleroma.Filter.create(query)
	{:ok, filter} = Pleroma.Filter.delete(query)
	assert is_nil(Repo.get(Pleroma.Filter, filter.filter_id))
	end

	test "getting all filters by an user" 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)
	filters = Pleroma.Filter.get_filters(user)
	assert filter_one in filters
	assert filter_two in filters
	end

	test "updating a filter" 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: 1,
	phrase: "who",
	context: ["home", "timeline"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.update(query_two)
	assert filter_one != filter_two
	assert filter_two.phrase == query_two.phrase
	assert filter_two.context == query_two.context
	end
	end
	diff --git a/test/list_test.exs b/test/list_test.exs
	index 19eef8f6b..2ab822815 100644
	--- a/test/list_test.exs
	+++ b/test/list_test.exs
	@@ -1,113 +1,112 @@
	defmodule Pleroma.ListTest do
	- alias Pleroma.{User, Repo}
	+ alias Pleroma.Repo
	use Pleroma.DataCase

	import Pleroma.Factory
	- import Ecto.Query

	test "creating a list" do
	user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", user)
	%Pleroma.List{title: title} = Pleroma.List.get(list.id, user)
	assert title == "title"
	end

	test "getting a list not belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", user)
	ret = Pleroma.List.get(list.id, other_user)
	assert is_nil(ret)
	end

	test "adding an user to a list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, %{following: following}} = Pleroma.List.follow(list, other_user)
	assert [other_user.follower_address] == following
	end

	test "removing an user from a list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	- {:ok, %{following: following}} = Pleroma.List.follow(list, other_user)
	+ {:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)
	{:ok, %{following: following}} = Pleroma.List.unfollow(list, other_user)
	assert [] == following
	end

	test "renaming a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, %{title: title}} = Pleroma.List.rename(list, "new")
	assert "new" == title
	end

	test "deleting a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, list} = Pleroma.List.delete(list)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "getting users in a list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)
	{:ok, following} = Pleroma.List.get_following(list)
	assert other_user in following
	assert third_user in following
	end

	test "getting all lists by an user" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list_one} = Pleroma.List.create("title", user)
	{:ok, list_two} = Pleroma.List.create("other title", user)
	{:ok, list_three} = Pleroma.List.create("third title", other_user)
	lists = Pleroma.List.for_user(user, %{})
	assert list_one in lists
	assert list_two in lists
	refute list_three in lists
	end

	test "getting all lists the user is a member of" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list_one} = Pleroma.List.create("title", user)
	{:ok, list_two} = Pleroma.List.create("other title", user)
	{:ok, list_three} = Pleroma.List.create("third title", other_user)
	{:ok, list_one} = Pleroma.List.follow(list_one, other_user)
	{:ok, list_two} = Pleroma.List.follow(list_two, other_user)
	{:ok, list_three} = Pleroma.List.follow(list_three, user)

	lists = Pleroma.List.get_lists_from_activity(%Pleroma.Activity{actor: other_user.ap_id})
	assert list_one in lists
	assert list_two in lists
	refute list_three in lists
	end

	test "getting own lists a given user belongs to" do
	owner = insert(:user)
	not_owner = insert(:user)
	member_1 = insert(:user)
	member_2 = insert(:user)
	{:ok, owned_list} = Pleroma.List.create("owned", owner)
	{:ok, not_owned_list} = Pleroma.List.create("not owned", not_owner)
	{:ok, owned_list} = Pleroma.List.follow(owned_list, member_1)
	{:ok, owned_list} = Pleroma.List.follow(owned_list, member_2)
	{:ok, not_owned_list} = Pleroma.List.follow(not_owned_list, member_1)
	{:ok, not_owned_list} = Pleroma.List.follow(not_owned_list, member_2)

	lists_1 = Pleroma.List.get_lists_account_belongs(owner, member_1.id)
	assert owned_list in lists_1
	refute not_owned_list in lists_1
	lists_2 = Pleroma.List.get_lists_account_belongs(owner, member_2.id)
	assert owned_list in lists_2
	refute not_owned_list in lists_2
	end
	end
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index a36ed5bb8..385210793 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,373 +1,373 @@
	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{User, Notification}
	alias Pleroma.Web.ActivityPub.Transmogrifier
	import Pleroma.Factory

	describe "create_notifications" do
	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

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

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert other_notification.activity_id == activity.id
	end
	end

	describe "create_notification" do
	test "it doesn't create a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, user} = User.block(user, author)

	assert nil == Notification.create_notification(activity, user)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	assert nil == Notification.create_notification(activity, author)
	end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	- {:ok, activity} =
	+ {:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	- {:ok, activity} =
	+ {:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = notifs = Notification.for_user(other_user)
	assert length(notifs) == 2

	assert n2.id > n1.id

	- {:ok, activity} =
	+ {:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	- [n3, n2, n1] = notifs = Notification.for_user(other_user)
	+ [n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false
	end
	end

	describe "notification target determination" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user not in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

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

	assert length(Notification.for_user(user)) == 1

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

	assert length(Notification.for_user(user)) == 0
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

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

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 0
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

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

	assert length(Notification.for_user(user)) == 1

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

	assert length(Notification.for_user(user)) == 0
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

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

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 0
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert length(Notification.for_user(user)) == 0

	{:error, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 0
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert length(Notification.for_user(user)) == 0

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert length(Notification.for_user(user)) == 0

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 0
	end

	test "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	"status" => "test reply",
	"in_reply_to_status_id" => activity.id
	})

	assert length(Notification.for_user(user)) == 0
	end
	end
	end
	diff --git a/test/plugs/user_is_admin_plug_test.exs b/test/plugs/user_is_admin_plug_test.exs
	index 031b2f466..cdab6b8ed 100644
	--- a/test/plugs/user_is_admin_plug_test.exs
	+++ b/test/plugs/user_is_admin_plug_test.exs
	@@ -1,39 +1,39 @@
	defmodule Pleroma.Plugs.UserIsAdminPlugTest do
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Plugs.UserIsAdminPlug
	import Pleroma.Factory

	- test "accepts a user that is admin", %{conn: conn} do
	+ test "accepts a user that is admin" do
	user = insert(:user, info: %{is_admin: true})

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

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

	assert conn == ret_conn
	end

	- test "denies a user that isn't admin", %{conn: conn} do
	+ test "denies a user that isn't admin" do
	user = insert(:user)

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

	assert conn.status == 403
	end

	- test "denies when a user isn't set", %{conn: conn} do
	+ test "denies when a user isn't set" do
	conn =
	build_conn()
	\|> UserIsAdminPlug.call(%{})

	assert conn.status == 403
	end
	end
	diff --git a/test/support/conn_case.ex b/test/support/conn_case.ex
	index 2e6707087..d25c28f49 100644
	--- a/test/support/conn_case.ex
	+++ b/test/support/conn_case.ex
	@@ -1,39 +1,40 @@
	defmodule Pleroma.Web.ConnCase do
	@moduledoc """
	This module defines the test case to be used by
	tests that require setting up a connection.

	Such tests rely on `Phoenix.ConnTest` and also
	import other functionality to make it easier
	to build common datastructures and query the data layer.

	Finally, if the test case interacts with the database,
	it cannot be async. For this reason, every test runs
	inside a transaction which is reset at the beginning
	of the test unless the test case is marked as async.
	"""

	use ExUnit.CaseTemplate

	using do
	quote do
	# Import conveniences for testing with connections
	use Phoenix.ConnTest
	+ use Pleroma.Tests.Helpers
	import Pleroma.Web.Router.Helpers

	# The default endpoint for testing
	@endpoint Pleroma.Web.Endpoint
	end
	end

	setup tags do
	Cachex.clear(:user_cache)
	:ok = Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)

	unless tags[:async] do
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
	end

	{:ok, conn: Phoenix.ConnTest.build_conn()}
	end
	end
	diff --git a/test/support/data_case.ex b/test/support/data_case.ex
	index 9dde6b5e5..53e7234d2 100644
	--- a/test/support/data_case.ex
	+++ b/test/support/data_case.ex
	@@ -1,71 +1,72 @@
	defmodule Pleroma.DataCase do
	@moduledoc """
	This module defines the setup for tests requiring
	access to the application's data layer.

	You may define functions here to be used as helpers in
	your tests.

	Finally, if the test case interacts with the database,
	it cannot be async. For this reason, every test runs
	inside a transaction which is reset at the beginning
	of the test unless the test case is marked as async.
	"""

	use ExUnit.CaseTemplate

	using do
	quote do
	alias Pleroma.Repo

	import Ecto
	import Ecto.Changeset
	import Ecto.Query
	import Pleroma.DataCase
	+ use Pleroma.Tests.Helpers
	end
	end

	setup tags do
	Cachex.clear(:user_cache)
	:ok = Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)

	unless tags[:async] do
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
	end

	:ok
	end

	def ensure_local_uploader(_context) do
	uploader = Pleroma.Config.get([Pleroma.Upload, :uploader])
	filters = Pleroma.Config.get([Pleroma.Upload, :filters])

	unless uploader == Pleroma.Uploaders.Local \|\| filters != [] do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([Pleroma.Upload, :filters], [])

	on_exit(fn ->
	Pleroma.Config.put([Pleroma.Upload, :uploader], uploader)
	Pleroma.Config.put([Pleroma.Upload, :filters], filters)
	end)
	end

	:ok
	end

	@doc """
	A helper that transform changeset errors to a map of messages.

	changeset = Accounts.create_user(%{password: "short"})
	assert "password is too short" in errors_on(changeset).password
	assert %{password: ["password is too short"]} = errors_on(changeset)

	"""
	def errors_on(changeset) do
	Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
	Enum.reduce(opts, message, fn {key, value}, acc ->
	String.replace(acc, "%{#{key}}", to_string(value))
	end)
	end)
	end
	end
	diff --git a/test/support/helpers.ex b/test/support/helpers.ex
	new file mode 100644
	index 000000000..64b6b1900
	--- /dev/null
	+++ b/test/support/helpers.ex
	@@ -0,0 +1,25 @@
	+defmodule Pleroma.Tests.Helpers do
	+ @moduledoc """
	+ Helpers for use in tests.
	+ """
	+
	+ defmacro __using__(_opts) do
	+ quote do
	+ def refresh_record(%{id: id, __struct__: model} = _),
	+ do: refresh_record(model, %{id: id})
	+
	+ def refresh_record(model, %{id: id} = _) do
	+ Pleroma.Repo.get_by(model, id: id)
	+ end
	+
	+ # Used for comparing json rendering during tests.
	+ def render_json(view, template, assigns) do
	+ assigns = Map.new(assigns)
	+
	+ view.render(template, assigns)
	+ \|> Poison.encode!()
	+ \|> Poison.decode!()
	+ end
	+ end
	+ end
	+end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 3d2f7f4e0..9baa5ef24 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,612 +1,635 @@
	defmodule Pleroma.UserTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.{User, Repo, Activity}
	- alias Pleroma.Web.OStatus
	- alias Pleroma.Web.Websub.WebsubClientSubscription
	alias Pleroma.Web.CommonAPI
	use Pleroma.DataCase

	import Pleroma.Factory
	- import Ecto.Query

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

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

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

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

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, info: %{locked: true})
	followed = insert(:user, info: %{locked: true})

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

	# {:ok, user} = User.follow(user, followed)
	# assert User.ap_followers(followed) in user.following

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

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

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

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = Repo.get(User, user.id)
	assert user.following == [user.ap_id]
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it ensures info is not nil" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	{:ok, user} =
	changeset
	\|> Repo.insert()

	refute is_nil(user.info)
	end
	end

	+ describe "get_or_fetch/1" do
	+ test "gets an existing user by nickname" do
	+ user = insert(:user)
	+ fetched_user = User.get_or_fetch(user.nickname)
	+
	+ assert user == fetched_user
	+ end
	+
	+ test "gets an existing user by ap_id" do
	+ ap_id = "http://mastodon.example.org/users/admin"
	+
	+ user =
	+ insert(
	+ :user,
	+ local: false,
	+ nickname: "admin@mastodon.example.org",
	+ ap_id: ap_id,
	+ info: %{}
	+ )
	+
	+ fetched_user = User.get_or_fetch(ap_id)
	+ freshed_user = refresh_record(user)
	+ assert freshed_user == fetched_user
	+ end
	+ end
	+
	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago,
	info: %{}
	)

	assert orig_user.last_refreshed_at == a_week_ago

	user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	assert user.info.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

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

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

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

	{:ok, res} = User.get_friends(user)

	followed_one = User.get_by_ap_id(followed_one.ap_id)
	followed_two = User.get_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

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

	assert user.info.note_count == 0

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

	assert user.info.note_count == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

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

	assert user.info.note_count == 1

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

	assert user.info.note_count == 2
	end

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

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

	assert user.info.note_count == 1

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

	assert user.info.note_count == 0

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

	assert user.info.note_count == 0
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info.follower_count == 0

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

	assert user.info.follower_count == 1
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

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

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

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

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = Repo.get(User, blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert [addressed] == User.get_recipients_from_activity(activity)

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert user in recipients
	assert addressed in recipients
	end

	test ".deactivate can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.info.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.info.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.info.deactivated
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

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

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

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

	{:ok, _} = User.delete(user)

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

	assert user.info.deactivated

	refute User.following?(user, followed)
	refute User.following?(followed, follower)

	# TODO: Remove favorites, repeats, delete activities.

	refute Repo.get(Activity, activity.id)
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns nil when rich-text is enabled" do
	user = insert(:user)

	assert nil == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, %{info: %{no_rich_text: true}})

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)
	- user_info = User.get_cached_user_info(user)
	+ _user_info = User.get_cached_user_info(user)

	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	{:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, _} = User.delete(user)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "User.search" do
	test "finds a user, ranking by similarity" do
	- user = insert(:user, %{name: "lain"})
	- user_two = insert(:user, %{name: "ean"})
	- user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	+ _user = insert(:user, %{name: "lain"})
	+ _user_two = insert(:user, %{name: "ean"})
	+ _user_three = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	user_four = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

	assert user_four ==
	User.search("lain@ple") \|> List.first() \|> Map.put(:search_distance, nil)
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_controller_test.exs b/test/web/activity_pub/activity_pub_controller_test.exs
	index b4af2df5a..faeace016 100644
	--- a/test/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,249 +1,249 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	alias Pleroma.Web.ActivityPub.{UserView, ObjectView}
	alias Pleroma.{Repo, User}
	alias Pleroma.Activity

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

	describe "/relay" do
	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	Pleroma.Config.put([:instance, :allow_relay], false)

	- res =
	- conn
	- \|> get(activity_pub_path(conn, :relay))
	- \|> json_response(404)
	+ conn
	+ \|> get(activity_pub_path(conn, :relay))
	+ \|> json_response(404)
	+ \|> assert

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

	describe "/users/:nickname" do
	test "it returns a json representation of the user", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

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

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end
	end

	describe "/object/:uuid" do
	test "it returns a json representation of the object", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	:timer.sleep(500)
	assert Activity.get_by_ap_id(data["id"])
	end
	end

	describe "/users/:nickname/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("bcc", [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	:timer.sleep(500)
	assert Activity.get_by_ap_id(data["id"])
	end
	end

	describe "/users/:nickname/outbox" do
	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox")

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

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox")

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

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns returns empty if the user has 'hide_network' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{info: %{hide_network: true}})
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	assert result["totalItems"] == 1
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns returns empty if the user has 'hide_network' set", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	assert result["totalItems"] == 1
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = Repo.get(User, user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 90f11ecd4..470ed08b2 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,575 +1,575 @@
	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Activity, Object, User}
	alias Pleroma.Builders.ActivityBuilder

	import Pleroma.Factory
	import Tesla.Mock

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

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.info.source_data
	assert user.info.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end
	end

	describe "insertion" do
	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity == new_activity
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	data = %{
	"ok" => true
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"ok" => true,
	"id" => given_id,
	"context" => "blabla"
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	data = %{
	"id" => "some_id",
	"object" => %{
	"id" => "object_id"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)

	assert is_binary(activity.data["context"])
	assert is_binary(activity.data["object"]["context"])
	assert activity.data["context_id"]
	assert activity.data["object"]["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	data = %{
	"object" => %{
	"type" => "Note",
	"ok" => true
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert is_binary(activity.data["object"]["id"])
	assert %Object{} = Object.get_by_ap_id(activity.data["object"]["id"])
	end
	end

	describe "create activities" do
	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2"]
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_activity_by_object_ap_id(id)
	activity_three = Repo.get(Activity, activity_three.id)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => nil})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	- {:ok, unlisted_activity} =
	+ {:ok, _unlisted_activity} =
	CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	activities = ActivityBuilder.insert_list(30)
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities()
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	later_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id
	last_expected = List.last(later_activities)

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
	last = List.last(activities)

	assert length(activities) == 10
	assert last == last_expected
	end

	test "retrieves ids up to max_id" do
	_first_activities = ActivityBuilder.insert_list(10)
	activities = ActivityBuilder.insert_list(20)
	later_activities = ActivityBuilder.insert_list(10)
	max_id = List.first(later_activities).id
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end
	end

	describe "like an object" do
	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]

	[note_activity] = Activity.all_by_object_ap_id(object.data["id"])
	assert note_activity.data["object"]["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, _, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

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

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	# {:ok, object} = ActivityPub.unannounce(user, object)
	# assert object.data["announcement_count"] == 0

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	announce_activity.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

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

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

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

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

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

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

	{:ok, object_again} =
	ActivityPub.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} = ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
	assert activity = Activity.get_create_activity_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	ActivityPub.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} = ActivityPub.fetch_object_from_id(last)

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

	describe "following / unfollowing" do
	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == followed.ap_id
	assert activity.data["object"]["id"] == follow_activity.data["id"]
	end
	end

	describe "blocking / unblocking" do
	test "creates a block activity" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity.data["type"] == "Block"
	assert activity.data["actor"] == blocker.ap_id
	assert activity.data["object"] == blocked.ap_id
	end

	test "creates an undo activity for the last block" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, block_activity} = ActivityPub.block(blocker, blocked)
	{:ok, activity} = ActivityPub.unblock(blocker, blocked)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == blocker.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Block"
	assert activity.data["object"]["object"] == blocked.ap_id
	assert activity.data["object"]["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.get_by_ap_id(note.data["object"]["id"])
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == note.data["object"]["id"]

	assert Repo.get(Activity, delete.id) != nil

	assert Repo.get(Object, object.id) == nil
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})

	{:ok, private_activity_1} =
	CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	"status" => "hi 3",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	"status" => "hi 4",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_2.id
	})

	assert user1.following == [user3.ap_id <> "/followers", user1.ap_id]

	activities = ActivityPub.fetch_activities([user1.ap_id \| user1.following])

	assert [public_activity, private_activity_1, private_activity_3] == activities
	assert length(activities) == 3

	activities = ActivityPub.contain_timeline(activities, user1)

	assert [public_activity, private_activity_1] == activities
	assert length(activities) == 2
	end
	end

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

	assert object
	end

	describe "update" do
	test "it creates an update activity with the new user data" do
	user = insert(:user)
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert update.data["object"]["id"] == user_data["id"]
	assert update.data["object"]["type"] == user_data["type"]
	end
	end

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

	assert object
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index fa526a222..0428e052d 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,1003 +1,1002 @@
	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.OStatus
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Web.Websub.WebsubClientSubscription

	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

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

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	test "it fetches replied-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data =
	data
	\|> Map.put("object", object)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity =
	Activity.get_create_activity_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_activity.data["object"]["inReplyToAtomUri"] ==
	"https://shitposter.club/notice/2827873"

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

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

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

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object = data["object"]
	assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object["actor"] == "http://mastodon.example.org/users/admin"
	assert object["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object["sensitive"] == true

	user = User.get_by_ap_id(object["actor"])

	assert user.info.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert Enum.at(data["object"]["tag"], 2) == "moo"
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

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

	assert data["object"]["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

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

	assert data["object"]["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

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

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

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

	assert data["object"]["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

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

	assert "test" in data["object"]["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

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

	assert data["object"]["url"] == "https://prismo.news/posts/83"
	end

	test "it works for incoming follow requests" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

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

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]["id"]
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

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

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_activity_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

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

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] == activity.data["object"]["id"]

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

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

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

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

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

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

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

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

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

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

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

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

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

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.info.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", activity.data["actor"])

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

	refute Repo.get(Activity, activity.id)
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

	data =
	data
	\|> Map.put("object", object)

	:error = Transmogrifier.handle_incoming(data)

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

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

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

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

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

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Announce"
	assert data["object"]["object"] == activity.data["object"]["id"]

	assert data["object"]["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

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

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", follow_data)

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

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

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

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

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

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_by_ap_id(data["actor"])
	blocked = User.get_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

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

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

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

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

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

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

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

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

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

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

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

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

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

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

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

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

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

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local

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

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

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

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end
	end

	describe "prepare outgoing" do
	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] ==
	Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it translates ostatus IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referent_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it translates ostatus reply_to IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referred_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["likes"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" 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"})
	})

	user_two = insert(:user, %{following: [user.follower_address]})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = Repo.get(User, user.id)
	assert user.info.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	assert user.info.ap_enabled
	assert user.info.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"

	# Wait for the background task
	:timer.sleep(1000)

	user = Repo.get(User, user.id)
	assert user.info.note_count == 1

	activity = Repo.get(Activity, activity.id)
	assert user.follower_address in activity.recipients

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

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

	refute "..." in activity.recipients

	unrelated_activity = Repo.get(Activity, unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = Repo.get(User, user_two.id)
	assert user.follower_address in user_two.following
	refute "..." in user_two.following
	end
	end

	describe "maybe_retire_websub" do
	test "it deletes all websub client subscripitions with the user as topic" do
	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
	{:ok, ws} = Repo.insert(subscription)

	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
	{:ok, ws2} = Repo.insert(subscription)

	Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")

	refute Repo.get(WebsubClientSubscription, ws.id)
	assert Repo.get(WebsubClientSubscription, ws2.id)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

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

	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

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

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

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

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end
	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 =
	Transmogrifier.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 =
	Transmogrifier.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 =
	Transmogrifier.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"})
	- })
	+ 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"})
	+ })

	{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	{:error, _} =
	ActivityPub.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index ba3b77fb6..4c12dd988 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,183 +1,181 @@
	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.{Repo, User}
	-
	import Pleroma.Factory
	- import ExUnit.CaptureLog

	describe "/api/pleroma/admin/user" do
	test "Delete" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")

	assert json_response(conn, 200) == user.nickname
	end

	test "Create" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/user", %{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	})

	assert json_response(conn, 200) == "lain"
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user1.id).tags == ["x", "foo", "bar"]
	assert Repo.get(User, user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user1.id).tags == []
	assert Repo.get(User, user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert Repo.get(User, user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/permission_group" do
	test "GET is giving user_info" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/permission_group/#{admin.nickname}")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}
	end

	test "/:right DELETE, can remove from a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	test "/api/pleroma/admin/invite_token" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/password_reset" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")

	assert conn.status == 200
	end
	end
	diff --git a/test/web/http_sigs/http_sig_test.exs b/test/web/http_sigs/http_sig_test.exs
	index 2e189d583..74d86a9e1 100644
	--- a/test/web/http_sigs/http_sig_test.exs
	+++ b/test/web/http_sigs/http_sig_test.exs
	@@ -1,195 +1,190 @@
	# 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/list_view_test.exs b/test/web/mastodon_api/list_view_test.exs
	index 5e36872ed..a12acc2b2 100644
	--- a/test/web/mastodon_api/list_view_test.exs
	+++ b/test/web/mastodon_api/list_view_test.exs
	@@ -1,19 +1,18 @@
	defmodule Pleroma.Web.MastodonAPI.ListViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Web.MastodonAPI.ListView
	- alias Pleroma.List

	test "Represent a list" do
	user = insert(:user)
	title = "mortal enemies"
	{:ok, list} = Pleroma.List.create(title, user)

	expected = %{
	id: to_string(list.id),
	title: title
	}

	assert expected == ListView.render("list.json", %{list: list})
	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 092f0c9fc..e8275d4ab 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,1412 +1,1418 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Repo, User, Object, Activity, Notification}
	alias Pleroma.Web.{OStatus, CommonAPI}
	alias Pleroma.Web.ActivityPub.ActivityPub
	-
	+ alias Pleroma.Web.MastodonAPI.FilterView
	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 =
	+ response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	-
	- assert response = json_response(conn, 200)
	+ \|> json_response(200)
	+
	+ assert response ==
	+ render_json(
	+ FilterView,
	+ "filters.json",
	+ filters: [filter_two, filter_one]
	+ )
	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)
	+ {: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} =
	+ {: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 data-user=\"#{user.id}\" 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 data-user=\"#{user.id}\" 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, user, "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)
	+ {: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)
	+ {: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)
	+ {: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
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(user)
	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 followers, hide_network", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: true}})
	- {:ok, user} = User.follow(user, other_user)
	+ {:ok, _user} = User.follow(user, other_user)

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

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

	test "getting followers, hide_network, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: true}})
	- {:ok, user} = User.follow(user, other_user)
	+ {:ok, _user} = User.follow(user, other_user)

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

	refute [] == json_response(conn, 200)
	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 "getting following, hide_network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

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

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

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

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

	refute [] == json_response(conn, 200)
	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 data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
	user2.id
	}\" 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/mastodon_socket_test.exs b/test/web/mastodon_api/mastodon_socket_test.exs
	index c7d71defc..5d9b96861 100644
	--- a/test/web/mastodon_api/mastodon_socket_test.exs
	+++ b/test/web/mastodon_api/mastodon_socket_test.exs
	@@ -1,33 +1,31 @@
	defmodule Pleroma.Web.MastodonApi.MastodonSocketTest do
	use Pleroma.DataCase

	- alias Pleroma.Web.MastodonApi.MastodonSocket
	alias Pleroma.Web.{Streamer, CommonAPI}
	- alias Pleroma.User

	import Pleroma.Factory

	test "public is working when non-authenticated" do
	user = insert(:user)

	task =
	Task.async(fn ->
	assert_receive {:text, _}, 4_000
	end)

	fake_socket = %{
	transport_pid: task.pid,
	assigns: %{}
	}

	topics = %{
	"public" => [fake_socket]
	}

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})

	Streamer.push_to_socket(topics, "public", activity)

	Task.await(task)
	end
	end
	diff --git a/test/web/oauth/authorization_test.exs b/test/web/oauth/authorization_test.exs
	index 98c7c4133..2b7fb2fad 100644
	--- a/test/web/oauth/authorization_test.exs
	+++ b/test/web/oauth/authorization_test.exs
	@@ -1,80 +1,80 @@
	defmodule Pleroma.Web.OAuth.AuthorizationTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OAuth.{Authorization, App}
	import Pleroma.Factory

	test "create an authorization token for a valid app" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	assert auth.user_id == user.id
	assert auth.app_id == app.id
	assert String.length(auth.token) > 10
	assert auth.used == false
	end

	test "use up a token" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	{:ok, auth} = Authorization.use_token(auth)

	assert auth.used == true

	assert {:error, "already used"} == Authorization.use_token(auth)

	expired_auth = %Authorization{
	user_id: user.id,
	app_id: app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), -10),
	token: "mytoken",
	used: false
	}

	{:ok, expired_auth} = Repo.insert(expired_auth)

	assert {:error, "token expired"} == Authorization.use_token(expired_auth)
	end

	test "delete authorizations" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)
	{:ok, auth} = Authorization.use_token(auth)

	- {auths, _} = Authorization.delete_user_authorizations(user)
	+ Authorization.delete_user_authorizations(user)

	{_, invalid} = Authorization.use_token(auth)

	assert auth != invalid
	end
	end
	diff --git a/test/web/oauth/token_test.exs b/test/web/oauth/token_test.exs
	index f926ff50b..e36ca5abc 100644
	--- a/test/web/oauth/token_test.exs
	+++ b/test/web/oauth/token_test.exs
	@@ -1,64 +1,64 @@
	defmodule Pleroma.Web.OAuth.TokenTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OAuth.{App, Token, Authorization}
	alias Pleroma.Repo

	import Pleroma.Factory

	test "exchanges a auth token for an access token" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	{:ok, token} = Token.exchange_token(app, auth)

	assert token.app_id == app.id
	assert token.user_id == user.id
	assert String.length(token.token) > 10
	assert String.length(token.refresh_token) > 10

	auth = Repo.get(Authorization, auth.id)
	{:error, "already used"} = Token.exchange_token(app, auth)
	end

	test "deletes all tokens of a user" do
	{:ok, app1} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client1",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	{:ok, app2} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client2",
	scopes: "scope",
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth1} = Authorization.create_authorization(app1, user)
	{:ok, auth2} = Authorization.create_authorization(app2, user)

	- {:ok, token1} = Token.exchange_token(app1, auth1)
	- {:ok, token2} = Token.exchange_token(app2, auth2)
	+ {:ok, _token1} = Token.exchange_token(app1, auth1)
	+ {:ok, _token2} = Token.exchange_token(app2, auth2)

	{tokens, _} = Token.delete_user_tokens(user)

	assert tokens == 2
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index 411e89e94..560305c15 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,237 +1,213 @@
	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

	setup_all do
	Tesla.Mock.mock_global(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()
	+ salmon_user
	+ \|> Ecto.Changeset.change()
	+ \|> 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)
	+ conn
	+ \|> get("/objects/#{uuid}")
	+ \|> response(404)
	end

	test "404s on nonexisting objects", %{conn: conn} do
	- url = "/objects/123"
	-
	- conn =
	- conn
	- \|> get(url)
	-
	- assert response(conn, 404)
	+ conn
	+ \|> get("/objects/123")
	+ \|> response(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)
	+ conn
	+ \|> get("/activities/#{uuid}")
	+ \|> response(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)
	+ conn
	+ \|> get("/activities/#{uuid}")
	+ \|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	- url = "/activities/123"
	-
	- conn =
	- conn
	- \|> get(url)
	-
	- assert response(conn, 404)
	+ conn
	+ \|> get("/activities/123")
	+ \|> response(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)
	+ conn
	+ \|> get("/notice/#{note_activity.id}")
	+ \|> response(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)
	+ conn
	+ \|> put_req_header("accept", "application/activity+json")
	+ \|> get("/notice/#{note_activity.id}")
	+ \|> json_response(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
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index f3268e83d..e577a6bee 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,520 +1,520 @@
	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	alias Pleroma.{Object, Repo, User, Activity}
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

	test "don't insert create notes twice" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert {:ok, [activity]} == OStatus.handle_incoming(incoming)
	end

	test "handle incoming note - GS, Salmon" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	user = User.get_by_ap_id(activity.data["actor"])
	assert user.info.note_count == 1
	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"

	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["object"]["published"] == "2017-04-23T14:51:03+00:00"

	assert activity.data["context"] ==
	"tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"

	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	assert activity.data["object"]["emoji"] == %{"marko" => "marko.png", "reimu" => "reimu.png"}
	assert activity.local == false
	end

	test "handle incoming notes - GS, subscription" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "Will it blend?"
	user = User.get_cached_by_ap_id(activity.data["actor"])
	assert User.ap_followers(user) in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with attachments - GS, subscription" do
	incoming = File.read!("test/fixtures/incoming_websub_gnusocial_attachments.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["attachment"] \|> length == 2
	assert activity.data["object"]["external_url"] == "https://social.heldscal.la/notice/2020923"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with tags" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post_tag.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["object"]["tag"] == ["nsfw"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, salmon, reply" do
	# It uses the context of the replied to object
	Repo.insert!(%Object{
	data: %{
	"id" => "https://pleroma.soykaf.com/objects/c237d966-ac75-4fe3-a87a-d89d71a3a7a4",
	"context" => "2hu"
	}
	})

	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["context"] == "2hu"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

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

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"]["summary"] == "technologic"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming unlisted messages, put public into cc" do
	incoming = File.read!("test/fixtures/mastodon-note-unlisted.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["cc"]
	end

	test "handle incoming retweets - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/cw_retweet.xml")
	{:ok, [[_activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert retweeted_activity.data["object"]["summary"] == "Hey."
	end

	test "handle incoming notes - GS, subscription, reply" do
	incoming = File.read!("test/fixtures/ostatus_incoming_reply.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"

	assert activity.data["object"]["content"] ==
	"@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."

	assert activity.data["object"]["inReplyTo"] ==
	"tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming retweets - GS, subscription" do
	incoming = File.read!("test/fixtures/share-gs.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert "https://pleroma.soykaf.com/users/lain" in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	assert String.contains?(retweeted_activity.data["object"]["content"], "mastodon")
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming retweets - GS, subscription - local message" do
	incoming = File.read!("test/fixtures/share-gs-local.xml")
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	incoming =
	incoming
	\|> String.replace("LOCAL_ID", note_activity.data["object"]["id"])
	\|> String.replace("LOCAL_USER", user.ap_id)

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

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert user.ap_id in activity.data["to"]
	refute activity.local

	retweeted_activity = Repo.get(Activity, retweeted_activity.id)
	assert note_activity.id == retweeted_activity.id
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == user.ap_id
	assert retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	end

	test "handle incoming retweets - Mastodon, salmon" do
	incoming = File.read!("test/fixtures/share.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:mastodon.social,2017-05-03:objectId=4934452:objectType=Status"

	refute activity.local
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	end

	test "handle incoming favorites - GS, websub" do
	capture_log(fn ->
	incoming = File.read!("test/fixtures/favorite.xml")
	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-05:fave:23211:comment:2061643:2017-05-05T09:12:50+00:00"

	refute activity.local
	assert favorited_activity.data["type"] == "Create"
	assert favorited_activity.data["actor"] == "https://shitposter.club/user/1"

	assert favorited_activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	refute favorited_activity.local
	end)
	end

	test "handle conversation references" do
	incoming = File.read!("test/fixtures/mastodon_conversation.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["context"] ==
	"tag:mastodon.social,2017-08-28:objectId=7876885:objectType=Conversation"
	end

	test "handle incoming favorites with locally available object - GS, websub" do
	note_activity = insert(:note_activity)

	incoming =
	File.read!("test/fixtures/favorite_with_local_note.xml")
	\|> String.replace("localid", note_activity.data["object"]["id"])

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

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]
	refute activity.local
	assert note_activity.id == favorited_activity.id
	assert favorited_activity.local
	end

	test "handle incoming replies" do
	incoming = File.read!("test/fixtures/incoming_note_activity_answer.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"

	assert activity.data["object"]["inReplyTo"] ==
	"http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"

	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]

	assert activity.data["object"]["id"] ==
	"tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming follows" do
	incoming = File.read!("test/fixtures/follow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert activity.data["type"] == "Follow"

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_by_ap_id(activity.data["actor"])
	followed = User.get_by_ap_id(activity.data["object"])

	assert User.following?(follower, followed)
	end

	test "handle incoming unfollows with existing follow" do
	incoming_follow = File.read!("test/fixtures/follow.xml")
	{:ok, [_activity]} = OStatus.handle_incoming(incoming_follow)

	incoming = File.read!("test/fixtures/unfollow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Undo"

	assert activity.data["id"] ==
	"undo:tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_by_ap_id(activity.data["actor"])
	followed = User.get_by_ap_id(activity.data["object"]["object"])

	refute User.following?(follower, followed)
	end

	describe "new remote user creation" do
	test "returns local users" do
	local_user = insert(:user)
	{:ok, user} = OStatus.find_or_make_user(local_user.ap_id)

	assert user == local_user
	end

	test "tries to use the information in poco fields" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)

	user = Repo.get(Pleroma.User, user.id)
	assert user.name == "Constance Variable"
	assert user.nickname == "lambadalambda@social.heldscal.la"
	assert user.local == false
	assert user.info.uri == uri
	assert user.ap_id == uri
	assert user.bio == "Call me Deacon Blues."
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_or_make_user(uri)

	assert user == user_again
	end

	test "find_or_make_user sets all the nessary input fields" do
	uri = "https://social.heldscal.la/user/23211"
	{:ok, user} = OStatus.find_or_make_user(uri)

	assert user.info ==
	%Pleroma.User.Info{
	id: user.info.id,
	ap_enabled: false,
	background: %{},
	banner: %{},
	blocks: [],
	deactivated: false,
	default_scope: "public",
	domain_blocks: [],
	follower_count: 0,
	is_admin: false,
	is_moderator: false,
	keys: nil,
	locked: false,
	no_rich_text: false,
	note_count: 0,
	settings: nil,
	source_data: %{},
	hub: "https://social.heldscal.la/main/push/hub",
	magic_key:
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB",
	salmon: "https://social.heldscal.la/main/salmon/user/23211",
	topic: "https://social.heldscal.la/api/statuses/user_timeline/23211.atom",
	uri: "https://social.heldscal.la/user/23211"
	}
	end

	test "find_make_or_update_user takes an author element and returns an updated user" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)
	old_name = user.name
	old_bio = user.bio
	change = Ecto.Changeset.change(user, %{avatar: nil, bio: nil, old_name: nil})

	{:ok, user} = Repo.update(change)
	refute user.avatar

	doc = XML.parse_document(File.read!("test/fixtures/23211.atom"))
	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, user} = OStatus.find_make_or_update_user(author)
	assert user.avatar["type"] == "Image"
	assert user.name == old_name
	assert user.bio == old_bio

	{:ok, user_again} = OStatus.find_make_or_update_user(author)
	assert user_again == user
	end
	end

	describe "gathering user info from a user id" do
	test "it returns user info in a hash" do
	user = "shp@social.heldscal.la"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "acct:shp@social.heldscal.la",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end

	test "it works with the uri" do
	user = "https://social.heldscal.la/user/29191"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "https://social.heldscal.la/user/29191",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end
	end

	describe "fetching a status by it's HTML url" do
	test "it builds a missing status from an html url" do
	capture_log(fn ->
	url = "https://shitposter.club/notice/2827873"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)

	assert activity.data["actor"] == "https://shitposter.club/user/1"

	assert activity.data["object"]["id"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "it works for atom notes, too" do
	url = "https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)
	assert activity.data["actor"] == "https://social.sakamoto.gq/users/eal"
	assert activity.data["object"]["id"] == url
	end
	end

	test "it doesn't add nil in the to field" do
	incoming = File.read!("test/fixtures/nil_mention_entry.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["to"] == [
	"http://localhost:4001/users/atarifrosch@social.stopwatchingus-heidelberg.de/followers",
	"https://www.w3.org/ns/activitystreams#Public"
	]
	end

	describe "is_representable?" do
	test "Note objects are representable" do
	note_activity = insert(:note_activity)

	assert OStatus.is_representable?(note_activity)
	end

	test "Article objects are not representable" do
	note_activity = insert(:note_activity)

	note_object = Object.normalize(note_activity.data["object"])

	note_data =
	note_object.data
	\|> Map.put("type", "Article")

	cs = Object.change(note_object, %{data: note_data})
	- {:ok, article_object} = Repo.update(cs)
	+ {:ok, _article_object} = Repo.update(cs)

	# the underlying object is now an Article instead of a note, so this should fail
	refute OStatus.is_representable?(note_activity)
	end
	end
	end
	diff --git a/test/web/retry_queue_test.exs b/test/web/retry_queue_test.exs
	index ce2964993..b5a6ab030 100644
	--- a/test/web/retry_queue_test.exs
	+++ b/test/web/retry_queue_test.exs
	@@ -1,31 +1,31 @@
	defmodule MockActivityPub do
	def publish_one(ret) do
	{ret, "success"}
	end
	end

	-defmodule Pleroma.ActivityTest do
	+defmodule Pleroma.Web.Federator.RetryQueueTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Federator.RetryQueue

	@small_retry_count 0
	@hopeless_retry_count 10

	test "failed posts are retried" do
	{:retry, _timeout} = RetryQueue.get_retry_params(@small_retry_count)

	assert {:noreply, %{delivered: 1}} ==
	RetryQueue.handle_info({:send, :ok, MockActivityPub, @small_retry_count}, %{
	delivered: 0
	})
	end

	test "posts that have been tried too many times are dropped" do
	{:drop, _timeout} = RetryQueue.get_retry_params(@hopeless_retry_count)

	assert {:noreply, %{dropped: 1}} ==
	RetryQueue.handle_cast({:maybe_enqueue, %{}, nil, @hopeless_retry_count}, %{
	dropped: 0
	})
	end
	end
	diff --git a/test/web/salmon/salmon_test.exs b/test/web/salmon/salmon_test.exs
	index 23ccc038e..7e922ad83 100644
	--- a/test/web/salmon/salmon_test.exs
	+++ b/test/web/salmon/salmon_test.exs
	@@ -1,106 +1,105 @@
	defmodule Pleroma.Web.Salmon.SalmonTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Salmon
	alias Pleroma.{Repo, Activity, User}
	import Pleroma.Factory
	- import Tesla.Mock

	@magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"

	@wrong_magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAA"

	@magickey_friendica "RSA.AMwa8FUs2fWEjX0xN7yRQgegQffhBpuKNC6fa5VNSVorFjGZhRrlPMn7TQOeihlc9lBz2OsHlIedbYn2uJ7yCs0.AQAB"

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

	test "decodes a salmon" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	{:ok, doc} = Salmon.decode_and_validate(@magickey, salmon)
	assert Regex.match?(~r/xml/, doc)
	end

	test "errors on wrong magic key" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	assert Salmon.decode_and_validate(@wrong_magickey, salmon) == :error
	end

	test "generates an RSA private key pem" do
	{:ok, key} = Salmon.generate_rsa_pem()
	assert is_binary(key)
	assert Regex.match?(~r/RSA/, key)
	end

	test "it encodes a magic key from a public key" do
	key = Salmon.decode_key(@magickey)
	magic_key = Salmon.encode_key(key)

	assert @magickey == magic_key
	end

	test "it decodes a friendica public key" do
	_key = Salmon.decode_key(@magickey_friendica)
	end

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

	assert elem(private, 0) == :RSAPrivateKey
	assert elem(public, 0) == :RSAPublicKey
	end

	test "encodes an xml payload with a private key" do
	doc = File.read!("test/fixtures/incoming_note_activity.xml")
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Salmon.keys_from_pem(pem)

	# Let's try a roundtrip.
	{:ok, salmon} = Salmon.encode(private, doc)
	{:ok, decoded_doc} = Salmon.decode_and_validate(Salmon.encode_key(public), salmon)

	assert doc == decoded_doc
	end

	test "it gets a magic key" do
	salmon = File.read!("test/fixtures/salmon2.xml")
	{:ok, key} = Salmon.fetch_magic_key(salmon)

	assert key ==
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB"
	end

	test "it pushes an activity to remote accounts it's addressed to" do
	user_data = %{
	info: %{
	- "salmon" => "http://example.org/salmon"
	+ salmon: "http://test-example.org/salmon"
	},
	local: false
	}

	mentioned_user = insert(:user, user_data)
	note = insert(:note)

	activity_data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"] ++ [mentioned_user.ap_id],
	"object" => note.data,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	{:ok, activity} = Repo.insert(%Activity{data: activity_data, recipients: activity_data["to"]})
	user = Repo.get_by(User, ap_id: activity.data["actor"])
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)

	- poster = fn url, _data, _headers, _options ->
	- assert url == "http://example.org/salmon"
	+ poster = fn url, _data, _headers ->
	+ assert url == "http://test-example.org/salmon"
	end

	Salmon.publish(user, activity, poster)
	end
	end
	diff --git a/test/web/twitter_api/representers/activity_representer_test.exs b/test/web/twitter_api/representers/activity_representer_test.exs
	index 7cae4e4a1..f6c60a744 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,197 +1,196 @@
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
	alias Pleroma.Web.ActivityPub.ActivityPub
	- alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.TwitterAPI.UserView
	import Pleroma.Factory

	test "an announce activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, announce_activity, _object} = ActivityPub.announce(user, object)
	note_activity = Activity.get_by_ap_id(note_activity.data["id"])

	status =
	ActivityRepresenter.to_map(announce_activity, %{
	users: [user, activity_actor],
	announced_activity: note_activity,
	for: user
	})

	assert status["id"] == announce_activity.id
	assert status["user"] == UserView.render("show.json", %{user: user, for: user})

	retweeted_status =
	ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})

	assert retweeted_status["repeated"] == true
	assert retweeted_status["id"] == note_activity.id
	assert status["statusnet_conversation_id"] == retweeted_status["statusnet_conversation_id"]

	assert status["retweeted_status"] == retweeted_status
	assert status["activity_type"] == "repeat"
	end

	test "a like activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

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

	status =
	ActivityRepresenter.to_map(like_activity, %{user: user, liked_activity: note_activity})

	assert status["id"] == like_activity.id
	assert status["in_reply_to_status_id"] == note_activity.id

	note_activity = Activity.get_by_ap_id(note_activity.data["id"])
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	liked_status = ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})
	assert liked_status["favorited"] == true
	assert status["activity_type"] == "like"
	end

	test "an activity" do
	user = insert(:user)
	# {:ok, mentioned_user } = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})
	mentioned_user = insert(:user, %{nickname: "shp"})

	# {:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	follower = insert(:user, %{following: [User.ap_followers(user)]})

	object = %Object{
	data: %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}
	}

	content_html =
	"<script>alert('YAY')</script>Some :2hu: content mentioning <a href='#{mentioned_user.ap_id}'>@shp</shp>"

	content = HtmlSanitizeEx.strip_tags(content_html)
	date = DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC") \|> DateTime.to_iso8601()

	{:ok, convo_object} = Object.context_mapping("2hu") \|> Repo.insert()

	to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public",
	mentioned_user.ap_id
	]

	activity = %Activity{
	id: 1,
	data: %{
	"type" => "Create",
	"id" => "id",
	"to" => to,
	"actor" => User.ap_id(user),
	"object" => %{
	"published" => date,
	"type" => "Note",
	"content" => content_html,
	"summary" => "2hu",
	"inReplyToStatusId" => 213_123,
	"attachment" => [
	object
	],
	"external_url" => "some url",
	"like_count" => 5,
	"announcement_count" => 3,
	"context" => "2hu",
	"tag" => ["content", "mentioning", "nsfw"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	},
	"published" => date,
	"context" => "2hu"
	},
	local: false,
	recipients: to
	}

	expected_html =
	"<p>2hu</p>alert('YAY')Some <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /> content mentioning <a href=\"#{
	mentioned_user.ap_id
	}\">@shp</a>"

	expected_status = %{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: follower}),
	"is_local" => false,
	"statusnet_html" => expected_html,
	"text" => "2hu" <> content,
	"is_post_verb" => true,
	"created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213_123,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"statusnet_conversation_id" => convo_object.id,
	"attachments" => [
	ObjectRepresenter.to_map(object)
	],
	"attentions" => [
	UserView.render("show.json", %{user: mentioned_user, for: follower})
	],
	"fave_num" => 5,
	"repeat_num" => 3,
	"favorited" => false,
	"repeated" => false,
	"external_url" => "some url",
	"tags" => ["nsfw", "content", "mentioning"],
	"activity_type" => "post",
	"possibly_sensitive" => true,
	"uri" => activity.data["object"]["id"],
	"visibility" => "direct",
	"summary" => "2hu"
	}

	assert ActivityRepresenter.to_map(activity, %{
	user: user,
	for: follower,
	mentioned: [mentioned_user]
	}) == expected_status
	end

	test "an undo for a follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _follow} = ActivityPub.follow(follower, followed)
	{:ok, unfollow} = ActivityPub.unfollow(follower, followed)

	map = ActivityRepresenter.to_map(unfollow, %{user: follower})
	assert map["is_post_verb"] == false
	assert map["activity_type"] == "undo"
	end

	test "a delete activity" do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])

	{:ok, delete} = ActivityPub.delete(object)

	map = ActivityRepresenter.to_map(delete, %{user: user})

	assert map["is_post_verb"] == false
	assert map["activity_type"] == "delete"
	assert map["uri"] == object.data["id"]
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_controller_test.exs b/test/web/twitter_api/twitter_api_controller_test.exs
	index 4119d1dd8..a30d415a7 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,1457 +1,1463 @@
	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	alias Pleroma.{Repo, Activity, User, Object, Notification}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Comeonin.Pbkdf2

	import Pleroma.Factory

	+ @banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
	+
	describe "POST /api/account/update_profile_banner" do
	test "it updates the banner", %{conn: conn} do
	user = insert(:user)

	- new_banner =
	- "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
	-
	- response =
	- conn
	- \|> assign(:user, user)
	- \|> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => new_banner})
	- \|> json_response(200)
	+ conn
	+ \|> assign(:user, user)
	+ \|> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
	+ \|> json_response(200)

	- user = Repo.get(User, user.id)
	+ user = refresh_record(user)
	assert user.info.banner["type"] == "Image"
	end
	end

	describe "POST /api/qvitter/update_background_image" do
	test "it updates the background", %{conn: conn} do
	user = insert(:user)

	- new_bg =
	- "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"
	-
	- response =
	- conn
	- \|> assign(:user, user)
	- \|> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => new_bg})
	- \|> json_response(200)
	+ conn
	+ \|> assign(:user, user)
	+ \|> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
	+ \|> json_response(200)

	- user = Repo.get(User, user.id)
	+ user = refresh_record(user)
	assert user.info.background["type"] == "Image"
	end
	end

	describe "POST /api/account/verify_credentials" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/account/verify_credentials.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	- conn =
	+ response =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/verify_credentials.json")
	+ \|> json_response(200)

	- assert response = json_response(conn, 200)
	assert response == UserView.render("show.json", %{user: user, token: response["token"]})
	end
	end

	describe "POST /statuses/update.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/statuses/update.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn_with_creds = conn \|> with_credentials(user.nickname, "test")
	request_path = "/api/statuses/update.json"

	error_response = %{
	"request" => request_path,
	"error" => "Client must provide a 'status' parameter with a value."
	}

	- conn = conn_with_creds \|> post(request_path)
	+ conn =
	+ conn_with_creds
	+ \|> post(request_path)
	+
	assert json_response(conn, 400) == error_response

	- conn = conn_with_creds \|> post(request_path, %{status: ""})
	+ conn =
	+ conn_with_creds
	+ \|> post(request_path, %{status: ""})
	+
	assert json_response(conn, 400) == error_response

	- conn = conn_with_creds \|> post(request_path, %{status: " "})
	+ conn =
	+ conn_with_creds
	+ \|> post(request_path, %{status: " "})
	+
	assert json_response(conn, 400) == error_response

	# we post with visibility private in order to avoid triggering relay
	- conn = conn_with_creds \|> post(request_path, %{status: "Nice meme.", visibility: "private"})
	+ conn =
	+ conn_with_creds
	+ \|> post(request_path, %{status: "Nice meme.", visibility: "private"})

	assert json_response(conn, 200) ==
	ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
	end
	end

	describe "GET /statuses/public_timeline.json" do
	test "returns statuses", %{conn: conn} do
	user = insert(:user)
	activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
	ActivityBuilder.insert_list(10, %{}, %{user: user})
	since_id = List.last(activities).id

	conn =
	conn
	\|> get("/api/statuses/public_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10
	end

	- test "returns 403 to unauthenticated request when the instance is not public" do
	+ test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	- test "returns 200 to unauthenticated request when the instance is public" do
	+ test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/public_and_external_timeline.json" do
	- test "returns 403 to unauthenticated request when the instance is not public" do
	+ test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	- test "returns 200 to unauthenticated request when the instance is public" do
	+ test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/show/:id.json" do
	test "returns one status", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

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

	response = json_response(conn, 200)

	assert response == ActivityRepresenter.to_map(activity, %{user: actor})
	end
	end

	describe "GET /users/show.json" do
	test "gets user with screen_name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets user with user_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets a user for a logged in user", %{conn: conn} do
	user = insert(:user)
	logged_in = insert(:user)

	{:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})

	conn =
	conn
	\|> with_credentials(logged_in.nickname, "test")
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["following"] == true
	end
	end

	describe "GET /statusnet/conversation/:id.json" do
	test "returns the statuses in the conversation", %{conn: conn} do
	{:ok, _user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})

	conn =
	conn
	\|> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")

	response = json_response(conn, 200)

	assert length(response) == 2
	end
	end

	describe "GET /statuses/friends_timeline.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/friends_timeline.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	user = insert(:user)

	activities =
	ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})

	returned_activities =
	ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})

	other_user = insert(:user)
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

	current_user =
	Ecto.Changeset.change(current_user, following: [User.ap_followers(user)])
	\|> Repo.update!()

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/friends_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10

	assert response ==
	Enum.map(returned_activities, fn activity ->
	ActivityRepresenter.to_map(activity, %{
	user: User.get_cached_by_ap_id(activity.data["actor"]),
	for: current_user
	})
	end)
	end
	end

	describe "GET /statuses/dm_timeline.json" do
	test "it show direct messages", %{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, direct_two} =
	CommonAPI.post(user_two, %{
	"status" => "Hi @#{user_one.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/statuses/dm_timeline.json")

	[status, status_two] = json_response(res_conn, 200)
	assert status["id"] == direct_two.id
	assert status_two["id"] == direct.id
	end
	end

	describe "GET /statuses/mentions.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/mentions.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/mentions.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert Enum.at(response, 0) ==
	ActivityRepresenter.to_map(activity, %{
	user: current_user,
	mentioned: [current_user]
	})
	end
	end

	describe "GET /api/qvitter/statuses/notifications.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/statuses/notifications.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert response ==
	NotificationView.render("notification.json", %{
	notifications: Notification.for_user(current_user),
	for: current_user
	})
	end
	end

	describe "POST /api/qvitter/statuses/notifications/read" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials, without any params", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify latest_id",
	"request" => "/api/qvitter/statuses/notifications/read"
	}
	end

	test "with credentials, with params", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 0

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 1
	end
	end

	describe "GET /statuses/user_timeline.json" do
	setup [:valid_user]

	test "without any params", %{conn: conn} do
	conn = get(conn, "/api/statuses/user_timeline.json")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify screen_name or user_id",
	"request" => "/api/statuses/user_timeline.json"
	}
	end

	test "with user_id", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with screen_name", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json")

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
	end

	test "with credentials with user_id", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials screen_name", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end
	end

	describe "POST /friendships/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/create.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert User.ap_followers(followed) in current_user.following

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /friendships/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	{:ok, current_user} = User.follow(current_user, followed)
	assert User.ap_followers(followed) in current_user.following
	ActivityPub.follow(current_user, followed)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/destroy.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == [current_user.ap_id]

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /blocks/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/create.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert User.blocks?(current_user, blocked)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "POST /blocks/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	{:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
	assert User.blocks?(current_user, blocked)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/destroy.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.info.blocks == []

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "GET /help/test.json" do
	test "returns \"ok\"", %{conn: conn} do
	conn = get(conn, "/api/help/test.json")
	assert json_response(conn, 200) == "ok"
	end
	end

	describe "POST /api/qvitter/update_avatar.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/update_avatar.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/update_avatar.json", %{img: avatar_image})

	current_user = Repo.get(User, current_user.id)
	assert is_map(current_user.avatar)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: current_user, for: current_user})
	end
	end

	describe "GET /api/qvitter/mutes.json" do
	setup [:valid_user]

	test "unimplemented mutes without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/mutes.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
	- conn =
	+ response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/mutes.json")
	+ \|> json_response(200)

	- current_user = Repo.get(User, current_user.id)
	-
	- assert [] = json_response(conn, 200)
	+ assert [] = response
	end
	end

	describe "POST /api/favorites/create/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end

	test "with credentials, invalid param", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/wrong.json")

	assert json_response(conn, 400)
	end

	test "with credentials, invalid activity", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/1.json")

	assert json_response(conn, 500)
	end
	end

	describe "POST /api/favorites/destroy/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	ActivityPub.like(current_user, object)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/destroy/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end
	end

	describe "POST /api/statuses/retweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/statuses/unretweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	_response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	request_path = String.replace(request_path, "retweet", "unretweet")

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/account/register" do
	test "it creates a new user", %{conn: conn} do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	user = json_response(conn, 200)

	fetched_user = Repo.get_by(User, nickname: "lain")
	assert user == UserView.render("show.json", %{user: fetched_user})
	end

	test "it returns errors on a problem", %{conn: conn} do
	data = %{
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	errors = json_response(conn, 400)

	assert is_binary(errors["error"])
	end
	end

	describe "GET /api/externalprofile/show" do
	test "it returns the user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})

	assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
	end
	end

	describe "GET /api/statuses/followers" do
	test "it returns a user's followers", %{conn: conn} do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	_not_follower = insert(:user)

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

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

	expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns a given user's followers with user_id", %{conn: conn} do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

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

	conn =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{
	users: [follower_one, follower_two],
	for: not_follower
	})
	)
	)
	end

	test "it returns empty for a hidden network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	- {:ok, follower_one} = User.follow(follower_one, user)
	- {:ok, follower_two} = User.follow(follower_two, user)
	+ {:ok, _follower_one} = User.follow(follower_one, user)
	+ {:ok, _follower_two} = User.follow(follower_two, user)

	- conn =
	+ response =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})
	+ \|> json_response(200)

	- assert [] == json_response(conn, 200)
	+ assert [] == response
	end

	test "it returns the followers for a hidden network if requested by the user themselves", %{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_network: true}})
	follower_one = insert(:user)
	follower_two = insert(:user)
	- not_follower = insert(:user)
	+ _not_follower = insert(:user)

	- {:ok, follower_one} = User.follow(follower_one, user)
	- {:ok, follower_two} = User.follow(follower_two, user)
	+ {:ok, _follower_one} = User.follow(follower_one, user)
	+ {:ok, _follower_two} = User.follow(follower_two, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

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

	describe "GET /api/statuses/friends" do
	test "it returns the logged in user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

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

	expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns a given user's friends with user_id", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end

	test "it returns empty for a hidden network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

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

	conn =
	conn
	\|> assign(:user, not_followed)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

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

	test "it returns friends for a hidden network if the user themselves request it", %{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_network: true}})
	followed_one = insert(:user)
	followed_two = insert(:user)
	- not_followed = insert(:user)
	+ _not_followed = insert(:user)

	- {:ok, user} = User.follow(user, followed_one)
	- {:ok, user} = User.follow(user, followed_two)
	+ {:ok, _user} = User.follow(user, followed_one)
	+ {:ok, _user} = User.follow(user, followed_two)

	- conn =
	+ response =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})
	+ \|> json_response(200)

	- refute [] == json_response(conn, 200)
	+ refute [] == response
	end

	test "it returns a given user's friends with screen_name", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"screen_name" => user.nickname})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end
	end

	describe "GET /friends/ids" do
	test "it returns a user's friends", %{conn: conn} do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	_not_followed = insert(:user)

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

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

	expected = [followed_one.id, followed_two.id]

	assert MapSet.equal?(
	MapSet.new(Poison.decode!(json_response(conn, 200))),
	MapSet.new(expected)
	)
	end
	end

	describe "POST /api/account/update_profile.json" do
	test "it updates a user's profile", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"name" => "new name",
	"description" => "hi @#{user2.nickname}"
	})

	user = Repo.get!(User, user.id)
	assert user.name == "new name"

	assert user.bio ==
	"hi <span><a data-user='#{user2.id}' class='mention' href='#{user2.ap_id}'>@<span>#{
	user2.nickname
	}</span></a></span>"

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it sets and un-sets hide_network", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_network" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_network == true

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_network" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_network == false
	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it locks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == true

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it unlocks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == false

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end
	end

	defp valid_user(_context) do
	user = insert(:user)
	[user: user]
	end

	defp with_credentials(conn, username, password) do
	header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	put_req_header(conn, "authorization", header_content)
	end

	describe "GET /api/search.json" do
	test "it returns search results", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

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

	conn =
	conn
	\|> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})

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

	describe "GET /api/statusnet/tags/timeline/:tag.json" do
	test "it returns the tags timeline", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/statusnet/tags/timeline/2hu.json")

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

	test "Convert newlines to <br> in bio", %{conn: conn} do
	user = insert(:user)

	_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"description" => "Hello,\r\nWorld! I\n am a test."
	})

	user = Repo.get!(User, user.id)
	assert user.bio == "Hello,<br>World! I<br> am a test."
	end

	describe "POST /api/pleroma/change_password" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_password")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and new password and confirmation not matching", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with credentials, valid password and invalid new password", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with credentials, valid password and matching new password and confirmation", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = Repo.get(User, current_user.id)
	assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "hi"})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials and valid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	# Wait a second for the started task to end
	:timer.sleep(1000)
	end
	end

	describe "GET /api/pleroma/friend_requests" do
	test "it lists friend requests" do
	user = insert(:user)
	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/pleroma/friend_requests")

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

	describe "POST /api/pleroma/friendships/approve" do
	test "it approves a friend request" do
	user = insert(:user)
	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/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})

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

	describe "POST /api/pleroma/friendships/deny" do
	test "it denies a friend request" do
	user = insert(:user)
	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/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})

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

	describe "GET /api/pleroma/search_user" do
	test "it returns users, ordered by similarity", %{conn: conn} do
	user = insert(:user, %{name: "eal"})
	user_two = insert(:user, %{name: "ean"})
	user_three = insert(:user, %{name: "ebn"})

	resp =
	conn
	\|> get(twitter_api_search__path(conn, :search_user), query: "eal")
	\|> json_response(200)

	assert length(resp) == 3
	assert [user.id, user_two.id, user_three.id] == Enum.map(resp, fn %{"id" => id} -> id end)
	end
	end

	describe "POST /api/media/upload" do
	setup context do
	Pleroma.DataCase.ensure_local_uploader(context)
	end

	test "it performs the upload and sets `data[actor]` with AP id of uploader user", %{
	conn: conn
	} do
	user = insert(:user)

	upload_filename = "test/fixtures/image_tmp.jpg"
	File.cp!("test/fixtures/image.jpg", upload_filename)

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

	response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/octet-stream")
	\|> post("/api/media/upload", %{
	"media" => file
	})
	\|> json_response(:ok)

	assert response["media_id"]
	object = Repo.get(Object, response["media_id"])
	assert object
	assert object.data["actor"] == User.ap_id(user)
	end
	end

	describe "POST /api/media/metadata/create" do
	setup do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])
	%{object: object, user: user}
	end

	test "it returns :forbidden status on attempt to modify someone else's upload", %{
	conn: conn,
	object: object
	} do
	initial_description = object.data["name"]
	another_user = insert(:user)

	conn
	\|> assign(:user, another_user)
	\|> post("/api/media/metadata/create", %{"media_id" => object.id})
	\|> json_response(:forbidden)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == initial_description
	end

	test "it updates `data[name]` of referenced Object with provided value", %{
	conn: conn,
	object: object,
	user: user
	} do
	description = "Informative description of the image. Initial value: #{object.data["name"]}}"

	conn
	\|> assign(:user, user)
	\|> post("/api/media/metadata/create", %{
	"media_id" => object.id,
	"alt_text" => %{"text" => description}
	})
	\|> json_response(:no_content)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == description
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 522cfd11d..3d3a637b7 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,429 +1,428 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	- alias Pleroma.Builders.UserBuilder
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView}
	alias Pleroma.{Activity, User, Object, Repo, UserInviteToken}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView

	import Pleroma.Factory

	test "create a status" do
	user = insert(:user)
	mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	"Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	expected_text =
	"Hello again, <span><a data-user='#{mentioned_user.id}' class='mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	assert get_in(activity.data, ["object", "content"]) == expected_text
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	activity.data["object"]["emoji"]

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_by_ap_id(user.ap_id)

	assert user.info.note_count == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply.data, ["object", "context"]) ==
	get_in(activity.data, ["object", "context"])

	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	assert User.blocks?(user, blocked)
	end

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info.blocks == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info.blocks == []
	end

	test "upload a file" do
	user = insert(:user)

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

	response = TwitterAPI.upload(file, user)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unfavorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, _like_activity, _object} = ActivityPub.like(user, object)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unretweets an already retweeted status" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
	{:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it registers a new user with empty string in bio and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	"nickname" => "john",
	"email" => "john@gmail.com",
	"fullname" => "John Doe",
	"bio" => "test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "@john test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	"<span><a data-user='#{user1.id}' class='mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it registers a new user via invite token and returns the user." do
	{:ok, token} = UserInviteToken.create_token()

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => token.token
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = Repo.get_by(User, nickname: "vinny")
	token = Repo.get_by(UserInviteToken, token: token.token)

	assert token.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it returns an error if invalid token submitted" do
	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => "DudeLetMeInImAFairy"
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Invalid token"
	refute Repo.get_by(User, nickname: "GrimReaper")
	end

	@moduletag skip: "needs 'registrations_open: false' in config"
	test "it returns an error if expired token submitted" do
	{:ok, token} = UserInviteToken.create_token()
	UserInviteToken.mark_as_used(token.token)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => token.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute Repo.get_by(User, nickname: "GrimReaper")
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute Repo.get_by(User, nickname: "lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = TwitterAPI.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert()
	conversation_id = TwitterAPI.context_to_conversation_id("random context")

	assert conversation_id == object.id
	end
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_activity_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	end
	end
	end
	diff --git a/test/web/twitter_api/views/notification_view_test.exs b/test/web/twitter_api/views/notification_view_test.exs
	index 79eafda7d..fcf2b3d90 100644
	--- a/test/web/twitter_api/views/notification_view_test.exs
	+++ b/test/web/twitter_api/views/notification_view_test.exs
	@@ -1,108 +1,107 @@
	defmodule Pleroma.Web.TwitterAPI.NotificationViewTest do
	use Pleroma.DataCase

	alias Pleroma.{User, Notification}
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.ActivityPub.ActivityPub
	- alias Pleroma.Builders.UserBuilder

	import Pleroma.Factory

	setup do
	user = insert(:user, bio: "<span>Here's some html</span>")
	[user: user]
	end

	test "A follow notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	follower = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	{:ok, activity} = ActivityPub.follow(follower, user)
	Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))
	[follow_notif] = Notification.for_user(user)

	represented = %{
	"created_at" => follow_notif.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: follower, for: user}),
	"id" => follow_notif.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "follow"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: follow_notif, for: user})
	end

	test "A mention notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: other_user, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" => ActivityView.render("activity.json", %{activity: activity, for: user}),
	"ntype" => "mention"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A retweet notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	repeater = insert(:user)

	- {:ok, activity} = TwitterAPI.repeat(repeater, note_activity.id)
	+ {:ok, _activity} = TwitterAPI.repeat(repeater, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: repeater, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "repeat"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end

	test "A like notification" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	liker = insert(:user)

	- {:ok, activity} = TwitterAPI.fav(liker, note_activity.id)
	+ {:ok, _activity} = TwitterAPI.fav(liker, note_activity.id)
	[notification] = Notification.for_user(user)

	represented = %{
	"created_at" => notification.inserted_at \|> Utils.format_naive_asctime(),
	"from_profile" => UserView.render("show.json", %{user: liker, for: user}),
	"id" => notification.id,
	"is_seen" => 0,
	"notice" =>
	ActivityView.render("activity.json", %{activity: notification.activity, for: user}),
	"ntype" => "like"
	}

	assert represented ==
	NotificationView.render("notification.json", %{notification: notification, for: user})
	end
	end
	diff --git a/test/web/twitter_api/views/user_view_test.exs b/test/web/twitter_api/views/user_view_test.exs
	index 9898c217d..34e6d4e27 100644
	--- a/test/web/twitter_api/views/user_view_test.exs
	+++ b/test/web/twitter_api/views/user_view_test.exs
	@@ -1,267 +1,266 @@
	defmodule Pleroma.Web.TwitterAPI.UserViewTest do
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.CommonAPI.Utils
	- alias Pleroma.Builders.UserBuilder

	import Pleroma.Factory

	setup do
	user = insert(:user, bio: "<span>Here's some html</span>")
	[user: user]
	end

	test "A user with only a nickname", %{user: user} do
	user = %{user \| name: nil, nickname: "scarlett@catgirl.science"}
	represented = UserView.render("show.json", %{user: user})
	assert represented["name"] == user.nickname
	assert represented["name_html"] == user.nickname
	end

	test "A user with an avatar object", %{user: user} do
	image = "image"
	user = %{user \| avatar: %{"url" => [%{"href" => image}]}}
	represented = UserView.render("show.json", %{user: user})
	assert represented["profile_image_url"] == image
	end

	- test "A user with emoji in username", %{user: user} do
	+ test "A user with emoji in username" do
	expected =
	"<img height=\"32px\" width=\"32px\" alt=\"karjalanpiirakka\" title=\"karjalanpiirakka\" src=\"/file.png\" /> man"

	user =
	insert(:user, %{
	info: %{
	source_data: %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}
	},
	name: ":karjalanpiirakka: man"
	})

	represented = UserView.render("show.json", %{user: user})
	assert represented["name_html"] == expected
	end

	test "A user" do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	{:ok, user} = User.update_note_count(user)
	follower = insert(:user)
	second_follower = insert(:user)

	User.follow(follower, user)
	User.follow(second_follower, user)
	User.follow(user, follower)
	{:ok, user} = User.update_follower_count(user)
	Cachex.put(:user_cache, "user_info:#{user.id}", User.user_info(Repo.get!(User, user.id)))

	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 1,
	"friends_count" => 1,
	"followers_count" => 2,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => [],
	"pleroma" => %{"tags" => []}
	}

	assert represented == UserView.render("show.json", %{user: user})
	end

	test "A user for a given other follower", %{user: user} do
	follower = insert(:user, %{following: [User.ap_followers(user)]})
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 1,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => true,
	"follows_you" => false,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => [],
	"pleroma" => %{"tags" => []}
	}

	assert represented == UserView.render("show.json", %{user: user, for: follower})
	end

	test "A user that follows you", %{user: user} do
	follower = insert(:user)
	{:ok, follower} = User.follow(follower, user)
	{:ok, user} = User.update_follower_count(user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => follower.id,
	"name" => follower.name,
	"screen_name" => follower.nickname,
	"name_html" => follower.name,
	"description" => HtmlSanitizeEx.strip_tags(follower.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(follower.bio),
	"created_at" => follower.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 1,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => true,
	"statusnet_blocking" => false,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => follower.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => [],
	"pleroma" => %{"tags" => []}
	}

	assert represented == UserView.render("show.json", %{user: follower, for: user})
	end

	test "a user that is a moderator" do
	user = insert(:user, %{info: %{is_moderator: true}})
	represented = UserView.render("show.json", %{user: user, for: user})

	assert represented["rights"]["delete_others_notice"]
	end

	test "A blocked user for the blocker" do
	user = insert(:user)
	blocker = insert(:user)
	User.block(blocker, user)
	image = "http://localhost:4001/images/avi.png"
	banner = "http://localhost:4001/images/banner.png"

	represented = %{
	"id" => user.id,
	"name" => user.name,
	"screen_name" => user.nickname,
	"name_html" => user.name,
	"description" => HtmlSanitizeEx.strip_tags(user.bio \|> String.replace("<br>", "\n")),
	"description_html" => HtmlSanitizeEx.basic_html(user.bio),
	"created_at" => user.inserted_at \|> Utils.format_naive_asctime(),
	"favourites_count" => 0,
	"statuses_count" => 0,
	"friends_count" => 0,
	"followers_count" => 0,
	"profile_image_url" => image,
	"profile_image_url_https" => image,
	"profile_image_url_profile_size" => image,
	"profile_image_url_original" => image,
	"following" => false,
	"follows_you" => false,
	"statusnet_blocking" => true,
	"rights" => %{
	"delete_others_notice" => false
	},
	"statusnet_profile_url" => user.ap_id,
	"cover_photo" => banner,
	"background_image" => nil,
	"is_local" => true,
	"locked" => false,
	"default_scope" => "public",
	"no_rich_text" => false,
	"fields" => [],
	"pleroma" => %{"tags" => []}
	}

	blocker = Repo.get(User, blocker.id)
	assert represented == UserView.render("show.json", %{user: user, for: blocker})
	end

	test "a user with mastodon fields" do
	fields = [
	%{
	"name" => "Pronouns",
	"value" => "she/her"
	},
	%{
	"name" => "Website",
	"value" => "https://example.org/"
	}
	]

	user =
	insert(:user, %{
	info: %{
	source_data: %{
	"attachment" =>
	Enum.map(fields, fn field -> Map.put(field, "type", "PropertyValue") end)
	}
	}
	})

	userview = UserView.render("show.json", %{user: user})
	assert userview["fields"] == fields
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 25, 6:34 AM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 39689
Default Alt Text: (331 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions