No OneTemporary
Actions

Authored By

Unknown

Size

114 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index dc534b05c..d873d7623 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1452 +1,1452 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Keys
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.RelMe
	alias Pleroma.Web.Websub

	require Logger

	@type t :: %__MODULE__{}

	@primary_key {:id, Pleroma.FlakeId, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@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])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	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_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	embeds_one(:info, User.Info)

	timestamps()
	end

	def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
	do: !Pleroma.Config.get([:instance, :account_activation_required])

	def auth_active?(%User{}), do: true

	def visible_for?(user, for_user \\ nil)

	def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true

	def visible_for?(%User{} = user, for_user) do
	auth_active?(user) \|\| superuser?(for_user)
	end

	def visible_for?(_, _), do: false

	def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
	def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
	def superuser?(_), do: false

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

	def banner_url(user, options \\ []) do
	case user.info.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{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{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	def user_info(%User{} = user) do
	%{
	following_count: following_count(user),
	note_count: user.info.note_count,
	follower_count: user.info.follower_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	end

	def restrict_deactivated(query) do
	from(u in query,
	where: not fragment("? \\? 'deactivated' AND ?->'deactivated' @> 'true'", u.info, u.info)
	)
	end

	def following_count(%User{following: []}), do: 0

	def following_count(%User{} = user) do
	user
	\|> get_friends_query()
	\|> Repo.aggregate(:count, :id)
	end

	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, :following])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> 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, local_nickname_regex())
	\|> 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 \\ %{}, opts \\ []) do
	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Pleroma.Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	info_change =
	User.Info.confirmation_changeset(%User.Info{}, need_confirmation: need_confirmation?)

	changeset =
	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)
	\|> put_change(:info, info_change)

	changeset =
	if opts[:external] do
	changeset
	else
	validate_required(changeset, [:email])
	end

	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)
	\|> unique_constraint(:ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

	defp autofollow_users(user) do
	candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset),
	{:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def try_send_confirmation_email(%User{} = user) do
	if user.info.confirmation_pending &&
	Pleroma.Config.get([:instance, :account_activation_required]) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	{:ok, :noop}
	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) >= 86_400
	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 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

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followed_addresses =
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.map(fn %{follower_address: fa} -> fa end)

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [
	set: [
	following:
	fragment(
	"array(select distinct unnest (array_cat(?, ?)))",
	u.following,
	^followed_addresses
	)
	]
	],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	Enum.each(followeds, fn followed ->
	update_follower_count(followed)
	end)

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	deny_follow_blocked = Pleroma.Config.get([:user, :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."}
	+ info.deactivated ->
	+ {:error, "Could not follow user: You are deactivated."}

	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

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [push: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	{:ok, _} = update_follower_count(followed)

	set_cache(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
	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [pull: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	{:ok, followed} = update_follower_count(followed)

	set_cache(follower)

	{: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_id(id) do
	Repo.get_by(User, id: id)
	end

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

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) 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}
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset) do
	set_cache(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_id(id) do
	key = "id:#{id}"

	ap_id =
	Cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	Cachex.fetch!(:user_cache, key, fn ->
	user_result = get_or_fetch_by_nickname(nickname)

	case user_result do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id) do
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)
	end

	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	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
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
	fetch_initial_posts(user)
	end

	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@doc "Fetch some posts when the user has just been federated with"
	def fetch_initial_posts(user),
	do: PleromaJobQueue.enqueue(:background, __MODULE__, [:fetch_initial_posts, user])

	@spec get_followers_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_followers_query(%User{} = user, nil) do
	User.Query.build(%{followers: user, deactivated: false})
	end

	def get_followers_query(user, page) do
	from(u in get_followers_query(user, nil))
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(user), do: get_followers_query(user, nil)

	def get_followers(user, page \\ nil) do
	q = get_followers_query(user, page)

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

	def get_followers_ids(user, page \\ nil) do
	q = get_followers_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(user, page) do
	from(u in get_friends_query(user, nil))
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(user), do: get_friends_query(user, nil)

	def get_friends(user, page \\ nil) do
	q = get_friends_query(user, page)

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

	def get_friends_ids(user, page \\ nil) do
	q = get_friends_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

	@spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
	def get_follow_requests(%User{} = user) do
	users =
	Activity.follow_requests_for_actor(user)
	\|> join(:inner, [a], u in User, on: a.actor == u.ap_id)
	\|> where([a, u], not fragment("? @> ?", u.following, ^[user.follower_address]))
	\|> group_by([a, u], u.id)
	\|> select([a, u], u)
	\|> Repo.all()

	{:ok, users}
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', ((?->>'note_count')::int + 1)::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	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)

	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end

	def update_follower_count(%User{} = user) do
	follower_count_query =
	User.Query.build(%{followers: user, deactivated: false})
	\|> select([u], %{count: count(u.id)})

	User
	\|> where(id: ^user.id)
	\|> join(:inner, [u], s in subquery(follower_count_query))
	\|> update([u, s],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{follower_count}', ?::varchar::jsonb, true)",
	u.info,
	s.count
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def remove_duplicated_following(%User{following: following} = user) do
	uniq_following = Enum.uniq(following)

	if length(following) == length(uniq_following) do
	{:ok, user}
	else
	user
	\|> update_changeset(%{following: uniq_following})
	\|> update_and_set_cache()
	end
	end

	@spec get_users_from_set([String.t()], boolean()) :: [User.t()]
	def get_users_from_set(ap_ids, local_only \\ true) do
	criteria = %{ap_id: ap_ids, deactivated: false}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to}) do
	User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
	\|> Repo.all()
	end

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

	if resolve, do: get_or_fetch(query)

	{:ok, results} =
	Repo.transaction(fn ->
	Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
	Repo.all(search_query(query, for_user))
	end)

	results
	end

	def search_query(query, for_user) do
	fts_subquery = fts_search_subquery(query)
	trigram_subquery = trigram_search_subquery(query)
	union_query = from(s in trigram_subquery, union_all: ^fts_subquery)
	distinct_query = from(s in subquery(union_query), order_by: s.search_type, distinct: s.id)

	from(s in subquery(boost_search_rank_query(distinct_query, for_user)),
	order_by: [desc: s.search_rank],
	limit: 40
	)
	end

	defp boost_search_rank_query(query, nil), do: query

	defp boost_search_rank_query(query, for_user) do
	friends_ids = get_friends_ids(for_user)
	followers_ids = get_followers_ids(for_user)

	from(u in subquery(query),
	select_merge: %{
	search_rank:
	fragment(
	"""
	CASE WHEN (?) THEN (?) * 1.3
	WHEN (?) THEN (?) * 1.2
	WHEN (?) THEN (?) * 1.1
	ELSE (?) END
	""",
	u.id in ^friends_ids and u.id in ^followers_ids,
	u.search_rank,
	u.id in ^friends_ids,
	u.search_rank,
	u.id in ^followers_ids,
	u.search_rank,
	u.search_rank
	)
	}
	)
	end

	defp fts_search_subquery(term, query \\ User) do
	processed_query =
	term
	\|> String.replace(~r/\W+/, " ")
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(&(&1 <> ":*"))
	\|> Enum.join(" \| ")

	from(
	u in query,
	select_merge: %{
	search_type: ^0,
	search_rank:
	fragment(
	"""
	ts_rank_cd(
	setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
	to_tsquery('simple', ?),
	32
	)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	},
	where:
	fragment(
	"""
	(setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	)
	\|> restrict_deactivated()
	end

	defp trigram_search_subquery(term) do
	from(
	u in User,
	select_merge: %{
	# ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
	search_type: fragment("?", 1),
	search_rank:
	fragment(
	"similarity(?, trim(? \|\| ' ' \|\| coalesce(?, '')))",
	^term,
	u.nickname,
	u.name
	)
	},
	where: fragment("trim(? \|\| ' ' \|\| coalesce(?, '')) % ?", u.nickname, u.name, ^term)
	)
	\|> restrict_deactivated()
	end

	def mute(muter, %User{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.add_to_mutes(ap_id)

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

	update_and_set_cache(cng)
	end

	def unmute(muter, %{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.remove_from_mutes(ap_id)

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

	update_and_set_cache(cng)
	end

	def subscribe(subscriber, %{ap_id: ap_id}) do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])

	with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
	blocked = blocks?(subscribed, subscriber) and deny_follow_blocked

	if blocked do
	{:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
	else
	info_cng =
	subscribed.info
	\|> User.Info.add_to_subscribers(subscriber.ap_id)

	change(subscribed)
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end
	end
	end

	def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	info_cng =
	user.info
	\|> User.Info.remove_from_subscribers(unsubscriber.ap_id)

	change(user)
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end
	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

	blocker =
	if subscribed_to?(blocked, blocker) do
	{:ok, blocker} = unsubscribe(blocked, blocker)
	blocker
	else
	blocker
	end

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

	{:ok, blocker} = update_follower_count(blocker)

	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, get_cached_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 mutes?(nil, _), do: false
	def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)

	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 subscribed_to?(user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	Enum.member?(target.info.subscribers, user.ap_id)
	end
	end

	@spec muted_users(User.t()) :: [User.t()]
	def muted_users(user) do
	User.Query.build(%{ap_id: user.info.mutes, deactivated: false})
	\|> Repo.all()
	end

	@spec blocked_users(User.t()) :: [User.t()]
	def blocked_users(user) do
	User.Query.build(%{ap_id: user.info.blocks, deactivated: false})
	\|> Repo.all()
	end

	@spec subscribers(User.t()) :: [User.t()]
	def subscribers(user) do
	User.Query.build(%{ap_id: user.info.subscribers, deactivated: false})
	\|> Repo.all()
	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 deactivate_async(user, status \\ true) do
	PleromaJobQueue.enqueue(:background, __MODULE__, [:deactivate_async, user, status])
	end

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

	with {:ok, friends} <- User.get_friends(user),
	{:ok, followers} <- User.get_followers(user),
	{:ok, user} <-
	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache() do
	Enum.each(followers, &invalidate_cache(&1))
	Enum.each(friends, &update_follower_count(&1))

	{:ok, user}
	end
	end

	def update_notification_settings(%User{} = user, settings \\ %{}) do
	info_changeset = User.Info.update_notification_settings(user.info, settings)

	change(user)
	\|> put_embed(:info, info_changeset)
	\|> update_and_set_cache()
	end

	@spec delete(User.t()) :: :ok
	def delete(%User{} = user),
	do: PleromaJobQueue.enqueue(:background, __MODULE__, [:delete, user])

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	{:ok, user} = User.deactivate(user)

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

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

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

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

	delete_user_activities(user)
	end

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:fetch_initial_posts, %User{} = user) do
	pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])

	Enum.each(
	# Insert all the posts in reverse order, so they're in the right order on the timeline
	Enum.reverse(Utils.fetch_ordered_collection(user.info.source_data["outbox"], pages)),
	&Pleroma.Web.Federator.incoming_ap_doc/1
	)

	{:ok, user}
	end

	def perform(:deactivate_async, user, status), do: deactivate(user, status)

	@spec perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
	when is_list(blocked_identifiers) do
	Enum.map(
	blocked_identifiers,
	fn blocked_identifier ->
	with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
	{:ok, blocker} <- block(blocker, blocked),
	{:ok, _} <- ActivityPub.block(blocker, blocked) do
	blocked
	else
	err ->
	Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	@spec perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:follow_import, %User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	Enum.map(
	followed_identifiers,
	fn followed_identifier ->
	with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
	{:ok, follower} <- maybe_direct_follow(follower, followed),
	{:ok, _} <- ActivityPub.follow(follower, followed) do
	followed
	else
	err ->
	Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:blocks_import,
	blocker,
	blocked_identifiers
	])

	def follow_import(%User{} = follower, followed_identifiers) when is_list(followed_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:follow_import,
	follower,
	followed_identifiers
	])

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	stream =
	ap_id
	\|> Activity.query_by_actor()
	\|> Repo.stream()

	Repo.transaction(fn -> Enum.each(stream, &delete_activity(&1)) end, timeout: :infinity)

	{:ok, user}
	end

	defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
	Object.normalize(activity) \|> ActivityPub.delete()
	end

	defp delete_activity(_activity), do: "Doing nothing"

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

	@default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])

	def html_filter_policy(_), do: @default_scrubbers

	def fetch_by_ap_id(ap_id) do
	ap_try = ActivityPub.make_user_from_ap_id(ap_id)

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

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

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

	if !is_nil(user) and !User.needs_update?(user) do
	{:ok, user}
	else
	# Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
	should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])

	resp = fetch_by_ap_id(ap_id)

	if should_fetch_initial do
	with {:ok, %User{} = user} <- resp do
	fetch_initial_posts(user)
	end
	end

	resp
	end
	end

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

	if user = get_cached_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
	\|> :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 {:ok, %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
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])
	\|> remote_user_creation()
	\|> Repo.insert(on_conflict: :replace_all, conflict_target: :nickname)
	\|> set_cache()
	end

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

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.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 <- User.get_cached_by_id(a.id),
	%User{} = b <- User.get_cached_by_id(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 <- User.get_cached_by_id(a.id),
	%User{} = b <- User.get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	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(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(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})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase(&1))
	end

	defp local_nickname_regex do
	if Pleroma.Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	info: %User.Info{},
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, deactivated: false})
	\|> Repo.all()
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	target.ap_id not in user.info.muted_reblogs
	end

	@spec toggle_confirmation(User.t()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def toggle_confirmation(%User{} = user) do
	need_confirmation? = !user.info.confirmation_pending

	info_changeset =
	User.Info.confirmation_changeset(user.info, need_confirmation: need_confirmation?)

	user
	\|> change()
	\|> put_embed(:info, info_changeset)
	\|> update_and_set_cache()
	end

	def get_mascot(%{info: %{mascot: %{} = mascot}}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{info: %{mascot: mascot}}) when is_nil(mascot) do
	# use instance-default
	config = Pleroma.Config.get([:assets, :mascots])
	default_mascot = Pleroma.Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def ensure_keys_present(user) do
	info = user.info

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

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

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

	update_and_set_cache(cng)
	end
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	select: u.ap_id
	)
	\|> Repo.all()
	end
	end
	diff --git a/test/web/activity_pub/transmogrifier/follow_handling_test.exs b/test/web/activity_pub/transmogrifier/follow_handling_test.exs
	new file mode 100644
	index 000000000..5ddf6cd52
	--- /dev/null
	+++ b/test/web/activity_pub/transmogrifier/follow_handling_test.exs
	@@ -0,0 +1,116 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Transmogrifier.FollowHandlingTest do
	+ use Pleroma.DataCase
	+ alias Pleroma.Activity
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+ alias Pleroma.Web.ActivityPub.Utils
	+
	+ import Pleroma.Factory
	+ import Ecto.Query
	+
	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ describe "handle_incoming" do
	+ 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_cached_by_ap_id(data["actor"]), user)
	+ end
	+
	+ test "it works for follow requests when you are already followed, creating a new accept activity" do
	+ # This is important because the remote might have the wrong idea about the
	+ # current follow status. This can lead to instance A thinking that x@A is
	+ # followed by y@B, but B thinks they are not. In this case, the follow can
	+ # never go through again because it will never get an Accept.
	+ user = insert(:user)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-follow-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	+
	+ accepts =
	+ from(
	+ a in Activity,
	+ where: fragment("?->>'type' = ?", a.data, "Accept")
	+ )
	+ \|> Repo.all()
	+
	+ assert length(accepts) == 1
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-follow-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("id", String.replace(data["id"], "2", "3"))
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	+
	+ accepts =
	+ from(
	+ a in Activity,
	+ where: fragment("?->>'type' = ?", a.data, "Accept")
	+ )
	+ \|> Repo.all()
	+
	+ assert length(accepts) == 2
	+ end
	+
	+ test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
	+ Pleroma.Config.put([:user, :deny_follow_blocked], true)
	+
	+ user = insert(:user)
	+ {:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")
	+
	+ {:ok, user} = User.block(user, target)
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-follow-activity.json")
	+ \|> Poison.decode!()
	+ \|> Map.put("object", user.ap_id)
	+
	+ {:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)
	+
	+ %Activity{} = activity = Activity.get_by_ap_id(id)
	+
	+ assert activity.data["state"] == "reject"
	+ 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_cached_by_ap_id(data["actor"]), user)
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index 89c8f79c9..28971ae45 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,1342 +1,1288 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	- alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.OStatus
	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)
	returned_object = Object.normalize(returned_activity.data["object"])

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

	assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
	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 = Object.normalize(data["object"]).data
	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_cached_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)
	object = Object.normalize(data["object"])

	assert Enum.at(object.data["tag"], 2) == "moo"
	end

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

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

	object = Object.normalize(activity)

	assert Enum.all?(object.data["oneOf"], fn choice ->
	choice["name"] in [
	"Dunno",
	"Everyone knows that!",
	"25 char limit is dumb",
	"I can't even fit a funny"
	]
	end)
	end

	test "it rewrites Note votes to Answers and increments vote counters on question activities" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	object = Object.normalize(activity)

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	answer_object = Object.normalize(activity)
	assert answer_object.data["type"] == "Answer"
	object = Object.get_by_ap_id(object.data["id"])

	assert Enum.any?(
	object.data["oneOf"],
	fn
	%{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
	_ -> false
	end
	)
	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)
	object = Object.normalize(data["object"])

	assert object.data["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)
	object = Object.normalize(data["object"])

	assert object.data["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)
	object = Object.normalize(data["object"])

	assert object.data["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)
	object = Object.normalize(data["object"])

	assert "test" in object.data["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)
	object = Object.normalize(data["object"])

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

	test "it cleans up incoming notices which are not really DMs" do
	user = insert(:user)
	other_user = insert(:user)

	to = [user.ap_id, other_user.ap_id]

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

	object =
	data["object"]
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

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

	assert data["to"] == []
	assert data["cc"] == to

	object_data = Object.normalize(activity).data

	assert object_data["to"] == []
	assert object_data["cc"] == to
	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_cached_by_ap_id(data["actor"]), user)
	- end
	-
	- test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
	- Pleroma.Config.put([:user, :deny_follow_blocked], true)
	-
	- user = insert(:user)
	- {:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")
	-
	- {:ok, user} = User.block(user, target)
	-
	- data =
	- File.read!("test/fixtures/mastodon-follow-activity.json")
	- \|> Poison.decode!()
	- \|> Map.put("object", user.ap_id)
	-
	- {:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)
	-
	- %Activity{} = activity = Activity.get_by_ap_id(id)
	-
	- assert activity.data["state"] == "reject"
	- 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_cached_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"])

	{: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"]
	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"])

	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"])

	{: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_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"])

	{: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"]

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

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", Object.normalize(activity).data["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

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

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

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

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	data = Map.put(data, "object", object)

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

	assert !is_nil(data["to"])
	assert !is_nil(data["cc"])
	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"])

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

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

	refute Activity.get_by_id(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"])

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

	:error = Transmogrifier.handle_incoming(data)

	assert Activity.get_by_id(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"])

	{: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"]

	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_cached_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_cached_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_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_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_cached_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 = User.get_cached_by_id(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 = User.get_cached_by_id(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 = User.get_cached_by_id(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 = User.get_cached_by_id(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 = User.get_cached_by_id(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 = User.get_cached_by_id(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 = User.get_cached_by_id(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

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	object = Object.normalize(activity.data["object"])

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, object.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

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

	assert activity.data["object"] == [user.ap_id, object.data["id"]]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	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 :firefox:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	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

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	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

	test "it adds like collection to object" do
	activity = insert(:note_activity)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["likes"]["type"] == "OrderedCollection"
	assert modified["object"]["likes"]["totalItems"] == 0
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	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 = User.get_cached_by_id(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"

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 1

	activity = Activity.get_by_id(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 = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_cached_by_id(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 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 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 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 "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

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

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end

	test "Rewrites Answers to Notes" do
	user = insert(:user)

	{:ok, poll_activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	poll_object = Object.normalize(poll_activity)
	# TODO: Replace with CommonAPI vote creation when implemented
	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

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

	assert data["object"]["type"] == "Note"
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index d601c8f1f..475531a09 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,721 +1,719 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Pleroma.Factory

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

	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 :firefox: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
	object = Object.normalize(activity.data["object"])

	expected_text =
	"Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :firefox: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' 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(object.data, ["content"]) == expected_text
	assert get_in(object.data, ["type"]) == "Note"
	assert get_in(object.data, ["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 %{"firefox" => "http://localhost:4001/emoji/Firefox.gif"} = object.data["emoji"]

	# hashtags
	assert object.data["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(object.data, ["context"]))

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

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

	user = User.get_cached_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)
	object = Object.normalize(activity.data["object"])

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)
	reply_object = Object.normalize(reply.data["object"])

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply_object.data, ["context"]) == get_in(object.data, ["context"])

	assert get_in(reply_object.data, ["inReplyTo"]) == get_in(activity.data, ["object"])
	assert Activity.get_in_reply_to_activity(reply).id == 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."
	+ {:ok, _, _, _} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	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_cached_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."
	+ {:ok, _, _, _} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	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)
	other_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 ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 1

	assert status == updated_activity

	{:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 2

	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
	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 = User.get_cached_by_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 = User.get_cached_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it sends confirmation email if :account_activation_required is specified in instance config" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	assert user.info.confirmation_pending

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	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 class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	describe "register with one time token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	{:ok, invite} = UserInviteToken.create_invite()

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "returns error on invalid token" 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 User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on expired token" do
	{:ok, invite} = UserInviteToken.create_invite()
	UserInviteToken.update_invite!(invite, used: true)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees"
	}

	check_fn = fn invite ->
	data = Map.put(data, "token", invite.token)
	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	{:ok, data: data, check_fn: check_fn}
	end

	test "returns user on success", %{check_fn: check_fn} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})

	check_fn.(invite)

	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end

	test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})

	check_fn.(invite)

	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end

	test "returns an error on overdue date", %{data: data} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})

	data = Map.put(data, "token", invite.token)

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end
	end

	describe "registers with reusable token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success, after him registration fails" do
	{:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with reusable date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "error after max uses" do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)
	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on overdue date" do
	{:ok, invite} =
	UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on with overdue date and after max" do
	{:ok, invite} =
	UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 100)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	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 User.get_cached_by_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 "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_cached_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 12:06 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798940
Default Alt Text: (114 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions