No OneTemporary
Actions

Size

163 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/captcha/error.ex b/lib/pleroma/captcha/error.ex
	new file mode 100644
	index 000000000..ec77f1336
	--- /dev/null
	+++ b/lib/pleroma/captcha/error.ex
	@@ -0,0 +1,43 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Captcha.Error do
	+ import Pleroma.Web.Gettext
	+
	+ def message(_reason, opts \\ [])
	+
	+ def message(:missing_field, %{name: name}) do
	+ dgettext(
	+ "errors",
	+ "Invalid CAPTCHA (Missing parameter: %{name})",
	+ name: name
	+ )
	+ end
	+
	+ def message(:captcha_error, _) do
	+ dgettext("errors", "CAPTCHA Error")
	+ end
	+
	+ def message(:invalid, _) do
	+ dgettext("errors", "Invalid CAPTCHA")
	+ end
	+
	+ def message(:kocaptcha_service_unavailable, _) do
	+ dgettext("errors", "Kocaptcha service unavailable")
	+ end
	+
	+ def message(:expired, _) do
	+ dgettext("errors", "CAPTCHA expired")
	+ end
	+
	+ def message(:already_used, _) do
	+ dgettext("errors", "CAPTCHA already used")
	+ end
	+
	+ def message(:invalid_answer_data, _) do
	+ dgettext("errors", "Invalid answer data")
	+ end
	+
	+ def message(error, _), do: error
	+end
	diff --git a/lib/pleroma/web/api_spec/errors/registration_user_error.ex b/lib/pleroma/web/api_spec/errors/registration_user_error.ex
	new file mode 100644
	index 000000000..1e48e12c9
	--- /dev/null
	+++ b/lib/pleroma/web/api_spec/errors/registration_user_error.ex
	@@ -0,0 +1,33 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ApiSpec.Errors.RegistrationUserError do
	+ @behaviour Plug
	+
	+ import Plug.Conn, only: [put_status: 2]
	+ import Phoenix.Controller, only: [json: 2]
	+ alias Pleroma.Web.ApiSpec.RenderError
	+
	+ @impl Plug
	+ def init(opts), do: opts
	+
	+ @impl Plug
	+
	+ def call(conn, errors) do
	+ field_errors =
	+ errors
	+ \|> Enum.group_by(& &1.name)
	+ \|> Enum.into(%{}, fn {field, field_errors} ->
	+ {field, Enum.map(field_errors, &RenderError.message/1)}
	+ end)
	+
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{
	+ error: "Please review the submission",
	+ identifier: "review_submission",
	+ fields: field_errors
	+ })
	+ end
	+end
	diff --git a/lib/pleroma/web/api_spec/operations/account_operation.ex b/lib/pleroma/web/api_spec/operations/account_operation.ex
	index d90ddb787..d68501bb8 100644
	--- a/lib/pleroma/web/api_spec/operations/account_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/account_operation.ex
	@@ -1,769 +1,798 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.AccountOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Reference
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.AccountRelationship
	alias Pleroma.Web.ApiSpec.Schemas.ActorType
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.List
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	@spec create_operation() :: Operation.t()
	def create_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Register an account",
	description:
	"Creates a user and account records. Returns an account access token for the app that initiated the request. The app should save this token for later, and should wait for the user to confirm their account by clicking a link in their email inbox.",
	operationId: "AccountController.create",
	requestBody: request_body("Parameters", create_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", create_response()),
	- 400 => Operation.response("Error", "application/json", ApiError),
	+ 400 => Operation.response("Error", "application/json", error_response()),
	403 => Operation.response("Error", "application/json", ApiError),
	429 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def verify_credentials_operation do
	%Operation{
	tags: ["accounts"],
	description: "Test to make sure that the user token works.",
	summary: "Verify account credentials",
	operationId: "AccountController.verify_credentials",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => Operation.response("Account", "application/json", Account)
	}
	}
	end

	def update_credentials_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Update account credentials",
	description: "Update the user's display and preferences.",
	operationId: "AccountController.update_credentials",
	security: [%{"oAuth" => ["write:accounts"]}],
	requestBody: request_body("Parameters", update_credentials_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def relationships_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Check relationships to other accounts",
	operationId: "AccountController.relationships",
	description: "Find out whether a given account is followed, blocked, muted, etc.",
	security: [%{"oAuth" => ["read:follows"]}],
	parameters: [
	Operation.parameter(
	:id,
	:query,
	%Schema{
	oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
	},
	"Account IDs",
	example: "123"
	)
	],
	responses: %{
	200 => Operation.response("Account", "application/json", array_of_relationships())
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Account",
	operationId: "AccountController.show",
	description: "View information about a profile.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def statuses_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Statuses",
	operationId: "AccountController.statuses",
	description:
	"Statuses posted to the given account. Public (for public statuses only), or user token + `read:statuses` (for private statuses the user is authorized to see)",
	parameters:
	[
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:pinned, :query, BooleanLike, "Include only pinned statuses"),
	Operation.parameter(:tagged, :query, :string, "With tag"),
	Operation.parameter(
	:only_media,
	:query,
	BooleanLike,
	"Include only statuses with media attached"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike,
	"Include statuses from muted acccounts."
	),
	Operation.parameter(:exclude_reblogs, :query, BooleanLike, "Exclude reblogs"),
	Operation.parameter(:exclude_replies, :query, BooleanLike, "Exclude replies"),
	Operation.parameter(
	:exclude_visibilities,
	:query,
	%Schema{type: :array, items: VisibilityScope},
	"Exclude visibilities"
	)
	] ++ pagination_params(),
	responses: %{
	200 => Operation.response("Statuses", "application/json", array_of_statuses()),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def followers_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Followers",
	operationId: "AccountController.followers",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which follow the given account, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def following_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Following",
	operationId: "AccountController.following",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which the given account is following, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{200 => Operation.response("Accounts", "application/json", array_of_accounts())}
	}
	end

	def lists_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Lists containing this account",
	operationId: "AccountController.lists",
	security: [%{"oAuth" => ["read:lists"]}],
	description: "User lists that you have added this account to.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{200 => Operation.response("Lists", "application/json", array_of_lists())}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Follow",
	operationId: "AccountController.follow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Follow the given account",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	reblogs: %Schema{
	type: :boolean,
	description: "Receive this account's reblogs in home timeline? Defaults to true.",
	default: true
	}
	}
	},
	required: false
	),
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Unfollow",
	operationId: "AccountController.unfollow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Unfollow the given account",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mute_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Mute",
	operationId: "AccountController.mute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	requestBody: request_body("Parameters", mute_request()),
	description:
	"Mute the given account. Clients should filter statuses and notifications from this account, if received (e.g. due to a boost in the Home timeline).",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:notifications,
	:query,
	%Schema{allOf: [BooleanLike], default: true},
	"Mute notifications in addition to statuses? Defaults to `true`."
	)
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def unmute_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Unmute",
	operationId: "AccountController.unmute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	description: "Unmute the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def block_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Block",
	operationId: "AccountController.block",
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description:
	"Block the given account. Clients should filter statuses from this account if received (e.g. due to a boost in the Home timeline)",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def unblock_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Unblock",
	operationId: "AccountController.unblock",
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description: "Unblock the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def follow_by_uri_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Follow by URI",
	operationId: "AccountController.follows",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	requestBody: request_body("Parameters", follow_by_uri_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mutes_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Muted accounts",
	operationId: "AccountController.mutes",
	description: "Accounts the user has muted.",
	security: [%{"oAuth" => ["follow", "read:mutes"]}],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def blocks_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Blocked users",
	operationId: "AccountController.blocks",
	description: "View your blocks. See also accounts/:id/{block,unblock}",
	security: [%{"oAuth" => ["read:blocks"]}],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def endorsements_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Endorsements",
	operationId: "AccountController.endorsements",
	description: "Not implemented",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => empty_array_response()
	}
	}
	end

	def identity_proofs_operation do
	%Operation{
	tags: ["accounts"],
	summary: "Identity proofs",
	operationId: "AccountController.identity_proofs",
	# Validators complains about unused path params otherwise
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	description: "Not implemented",
	responses: %{
	200 => empty_array_response()
	}
	}
	end

	defp create_request do
	%Schema{
	title: "AccountCreateRequest",
	description: "POST body for creating an account",
	type: :object,
	required: [:username, :password, :agreement],
	properties: %{
	reason: %Schema{
	type: :string,
	nullable: true,
	description:
	"Text that will be reviewed by moderators if registrations require manual approval"
	},
	username: %Schema{type: :string, description: "The desired username for the account"},
	email: %Schema{
	type: :string,
	nullable: true,
	description:
	"The email address to be used for login. Required when `account_activation_required` is enabled.",
	format: :email
	},
	password: %Schema{
	type: :string,
	description: "The password to be used for login",
	format: :password
	},
	agreement: %Schema{
	allOf: [BooleanLike],
	description:
	"Whether the user agrees to the local rules, terms, and policies. These should be presented to the user in order to allow them to consent before setting this parameter to TRUE."
	},
	locale: %Schema{
	type: :string,
	nullable: true,
	description: "The language of the confirmation email that will be sent"
	},
	# Pleroma-specific properties:
	fullname: %Schema{type: :string, nullable: true, description: "Full name"},
	bio: %Schema{type: :string, description: "Bio", nullable: true, default: ""},
	captcha_solution: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha solution"
	},
	captcha_token: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha token"
	},
	captcha_answer_data: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha data"
	},
	token: %Schema{
	type: :string,
	nullable: true,
	description: "Invite token required when the registrations aren't public"
	}
	},
	example: %{
	"username" => "cofe",
	"email" => "cofe@example.com",
	"password" => "secret",
	"agreement" => "true",
	"bio" => "☕️"
	}
	}
	end

	+ defp error_response do
	+ %Schema{
	+ title: "AccountCreateErrorResponse",
	+ description: "Response schema for errors",
	+ type: :object,
	+ properties: %{
	+ identifier: %Schema{type: :string},
	+ message: %Schema{type: :string},
	+ fields: %Schema{
	+ type: :object,
	+ properties: %{
	+ captcha: %Schema{type: :array, items: %Schema{type: :string}},
	+ email: %Schema{type: :array, items: %Schema{type: :string}},
	+ invite: %Schema{type: :array, items: %Schema{type: :string}},
	+ password: %Schema{type: :array, items: %Schema{type: :string}},
	+ username: %Schema{type: :array, items: %Schema{type: :string}}
	+ }
	+ }
	+ },
	+ example: %{
	+ "error" => "Please review the submission",
	+ "identifier" => "review_submission",
	+ "fields" => %{
	+ "captcha" => ["Invalid CAPTCHA"]
	+ }
	+ }
	+ }
	+ end
	+
	# Note: this is a token response (if login succeeds!), but there's no oauth operation file yet.
	defp create_response do
	%Schema{
	title: "AccountCreateResponse",
	description: "Response schema for an account",
	type: :object,
	properties: %{
	# The response when auto-login on create succeeds (token is issued):
	token_type: %Schema{type: :string},
	access_token: %Schema{type: :string},
	refresh_token: %Schema{type: :string},
	scope: %Schema{type: :string},
	created_at: %Schema{type: :integer, format: :"date-time"},
	me: %Schema{type: :string},
	expires_in: %Schema{type: :integer},
	#
	# The response when registration succeeds but auto-login fails (no token):
	identifier: %Schema{type: :string},
	message: %Schema{type: :string}
	},
	# Note: example of successful registration with failed login response:
	# example: %{
	# "identifier" => "missing_confirmed_email",
	# "message" => "You have been registered. Please check your email for further instructions."
	# },
	example: %{
	"token_type" => "Bearer",
	"access_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzk",
	"refresh_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzz",
	"created_at" => 1_585_918_714,
	"expires_in" => 600,
	"scope" => "read write follow push",
	"me" => "https://gensokyo.2hu/users/raymoo"
	}
	}
	end

	defp update_credentials_request do
	%Schema{
	title: "AccountUpdateCredentialsRequest",
	description: "POST body for creating an account",
	type: :object,
	properties: %{
	bot: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the account has a bot flag."
	},
	display_name: %Schema{
	type: :string,
	nullable: true,
	description: "The display name to use for the profile."
	},
	note: %Schema{type: :string, description: "The account bio."},
	avatar: %Schema{
	type: :string,
	nullable: true,
	description: "Avatar image encoded using multipart/form-data",
	format: :binary
	},
	header: %Schema{
	type: :string,
	nullable: true,
	description: "Header image encoded using multipart/form-data",
	format: :binary
	},
	locked: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether manual approval of follow requests is required."
	},
	accepts_chat_messages: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the user accepts receiving chat messages."
	},
	fields_attributes: %Schema{
	nullable: true,
	oneOf: [
	%Schema{type: :array, items: attribute_field()},
	%Schema{type: :object, additionalProperties: attribute_field()}
	]
	},
	# NOTE: `source` field is not supported
	#
	# source: %Schema{
	# type: :object,
	# properties: %{
	# privacy: %Schema{type: :string},
	# sensitive: %Schema{type: :boolean},
	# language: %Schema{type: :string}
	# }
	# },

	# Pleroma-specific fields
	no_rich_text: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "html tags are stripped from all statuses requested from the API"
	},
	hide_followers: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's followers will be hidden"
	},
	hide_follows: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follows will be hidden"
	},
	hide_followers_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follower count will be hidden"
	},
	hide_follows_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follow count will be hidden"
	},
	hide_favorites: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's favorites timeline will be hidden"
	},
	show_role: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's role (e.g admin, moderator) will be exposed to anyone in the
	API"
	},
	default_scope: VisibilityScope,
	pleroma_settings_store: %Schema{
	type: :object,
	nullable: true,
	description: "Opaque user settings to be saved on the backend."
	},
	skip_thread_containment: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Skip filtering out broken threads"
	},
	allow_following_move: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Allows automatically follow moved following accounts"
	},
	pleroma_background_image: %Schema{
	type: :string,
	nullable: true,
	description: "Sets the background image of the user.",
	format: :binary
	},
	discoverable: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description:
	"Discovery of this account in search results and other services is allowed."
	},
	actor_type: ActorType
	},
	example: %{
	bot: false,
	display_name: "cofe",
	note: "foobar",
	fields_attributes: [%{name: "foo", value: "bar"}],
	no_rich_text: false,
	hide_followers: true,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	hide_favorites: false,
	show_role: false,
	default_scope: "private",
	pleroma_settings_store: %{"pleroma-fe" => %{"key" => "val"}},
	skip_thread_containment: false,
	allow_following_move: false,
	discoverable: false,
	actor_type: "Person"
	}
	}
	end

	def array_of_accounts do
	%Schema{
	title: "ArrayOfAccounts",
	type: :array,
	items: Account,
	example: [Account.schema().example]
	}
	end

	defp array_of_relationships do
	%Schema{
	title: "ArrayOfRelationships",
	description: "Response schema for account relationships",
	type: :array,
	items: AccountRelationship,
	example: [
	%{
	"id" => "1",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => false,
	"muting_notifications" => false,
	"requested" => false,
	"domain_blocking" => false,
	"subscribing" => false,
	"endorsed" => true
	},
	%{
	"id" => "2",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => true,
	"muting_notifications" => false,
	"requested" => true,
	"domain_blocking" => false,
	"subscribing" => false,
	"endorsed" => false
	},
	%{
	"id" => "3",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => true,
	"blocked_by" => false,
	"muting" => true,
	"muting_notifications" => false,
	"requested" => false,
	"domain_blocking" => true,
	"subscribing" => true,
	"endorsed" => false
	}
	]
	}
	end

	defp follow_by_uri_request do
	%Schema{
	title: "AccountFollowsRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	uri: %Schema{type: :string, nullable: true, format: :uri}
	},
	required: [:uri]
	}
	end

	defp mute_request do
	%Schema{
	title: "AccountMuteRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	notifications: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Mute notifications in addition to statuses? Defaults to true.",
	default: true
	}
	},
	example: %{
	"notifications" => true
	}
	}
	end

	defp array_of_lists do
	%Schema{
	title: "ArrayOfLists",
	description: "Response schema for lists",
	type: :array,
	items: List,
	example: [
	%{"id" => "123", "title" => "my list"},
	%{"id" => "1337", "title" => "anotehr list"}
	]
	}
	end

	defp array_of_statuses do
	%Schema{
	title: "ArrayOfStatuses",
	type: :array,
	items: Status
	}
	end

	defp attribute_field do
	%Schema{
	title: "AccountAttributeField",
	description: "Request schema for account custom fields",
	type: :object,
	properties: %{
	name: %Schema{type: :string},
	value: %Schema{type: :string}
	},
	required: [:name, :value],
	example: %{
	"name" => "Website",
	"value" => "https://pleroma.com"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/render_error.ex b/lib/pleroma/web/api_spec/render_error.ex
	index d476b8ef3..59154b39e 100644
	--- a/lib/pleroma/web/api_spec/render_error.ex
	+++ b/lib/pleroma/web/api_spec/render_error.ex
	@@ -1,234 +1,234 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.RenderError do
	@behaviour Plug

	import Plug.Conn, only: [put_status: 2]
	import Phoenix.Controller, only: [json: 2]
	import Pleroma.Web.Gettext

	@impl Plug
	def init(opts), do: opts

	@impl Plug

	def call(conn, errors) do
	errors =
	Enum.map(errors, fn
	%{name: nil, reason: :invalid_enum} = err ->
	%OpenApiSpex.Cast.Error{err \| name: err.value}

	%{name: nil} = err ->
	%OpenApiSpex.Cast.Error{err \| name: List.last(err.path)}

	err ->
	err
	end)

	conn
	\|> put_status(:bad_request)
	\|> json(%{
	error: errors \|> Enum.map(&message/1) \|> Enum.join(" "),
	errors: errors \|> Enum.map(&render_error/1)
	})
	end

	defp render_error(error) do
	pointer = OpenApiSpex.path_to_string(error)

	%{
	title: "Invalid value",
	source: %{
	pointer: pointer
	},
	message: OpenApiSpex.Cast.Error.message(error)
	}
	end

	- defp message(%{reason: :invalid_schema_type, type: type, name: name}) do
	+ def message(%{reason: :invalid_schema_type, type: type, name: name}) do
	gettext("%{name} - Invalid schema.type. Got: %{type}.",
	name: name,
	type: inspect(type)
	)
	end

	- defp message(%{reason: :null_value, name: name} = error) do
	+ def message(%{reason: :null_value, name: name} = error) do
	case error.type do
	nil ->
	gettext("%{name} - null value.", name: name)

	type ->
	gettext("%{name} - null value where %{type} expected.",
	name: name,
	type: type
	)
	end
	end

	- defp message(%{reason: :all_of, meta: %{invalid_schema: invalid_schema}}) do
	+ def message(%{reason: :all_of, meta: %{invalid_schema: invalid_schema}}) do
	gettext(
	"Failed to cast value as %{invalid_schema}. Value must be castable using `allOf` schemas listed.",
	invalid_schema: invalid_schema
	)
	end

	- defp message(%{reason: :any_of, meta: %{failed_schemas: failed_schemas}}) do
	+ def message(%{reason: :any_of, meta: %{failed_schemas: failed_schemas}}) do
	gettext("Failed to cast value using any of: %{failed_schemas}.",
	failed_schemas: failed_schemas
	)
	end

	- defp message(%{reason: :one_of, meta: %{failed_schemas: failed_schemas}}) do
	+ def message(%{reason: :one_of, meta: %{failed_schemas: failed_schemas}}) do
	gettext("Failed to cast value to one of: %{failed_schemas}.", failed_schemas: failed_schemas)
	end

	- defp message(%{reason: :min_length, length: length, name: name}) do
	+ def message(%{reason: :min_length, length: length, name: name}) do
	gettext("%{name} - String length is smaller than minLength: %{length}.",
	name: name,
	length: length
	)
	end

	- defp message(%{reason: :max_length, length: length, name: name}) do
	+ def message(%{reason: :max_length, length: length, name: name}) do
	gettext("%{name} - String length is larger than maxLength: %{length}.",
	name: name,
	length: length
	)
	end

	- defp message(%{reason: :unique_items, name: name}) do
	+ def message(%{reason: :unique_items, name: name}) do
	gettext("%{name} - Array items must be unique.", name: name)
	end

	- defp message(%{reason: :min_items, length: min, value: array, name: name}) do
	+ def message(%{reason: :min_items, length: min, value: array, name: name}) do
	gettext("%{name} - Array length %{length} is smaller than minItems: %{min}.",
	name: name,
	length: length(array),
	min: min
	)
	end

	- defp message(%{reason: :max_items, length: max, value: array, name: name}) do
	+ def message(%{reason: :max_items, length: max, value: array, name: name}) do
	gettext("%{name} - Array length %{length} is larger than maxItems: %{}.",
	name: name,
	length: length(array),
	max: max
	)
	end

	- defp message(%{reason: :multiple_of, length: multiple, value: count, name: name}) do
	+ def message(%{reason: :multiple_of, length: multiple, value: count, name: name}) do
	gettext("%{name} - %{count} is not a multiple of %{multiple}.",
	name: name,
	count: count,
	multiple: multiple
	)
	end

	- defp message(%{reason: :exclusive_max, length: max, value: value, name: name})
	- when value >= max do
	+ def message(%{reason: :exclusive_max, length: max, value: value, name: name})
	+ when value >= max do
	gettext("%{name} - %{value} is larger than exclusive maximum %{max}.",
	name: name,
	value: value,
	max: max
	)
	end

	- defp message(%{reason: :maximum, length: max, value: value, name: name})
	- when value > max do
	+ def message(%{reason: :maximum, length: max, value: value, name: name})
	+ when value > max do
	gettext("%{name} - %{value} is larger than inclusive maximum %{max}.",
	name: name,
	value: value,
	max: max
	)
	end

	- defp message(%{reason: :exclusive_multiple, length: min, value: value, name: name})
	- when value <= min do
	+ def message(%{reason: :exclusive_multiple, length: min, value: value, name: name})
	+ when value <= min do
	gettext("%{name} - %{value} is smaller than exclusive minimum %{min}.",
	name: name,
	value: value,
	min: min
	)
	end

	- defp message(%{reason: :minimum, length: min, value: value, name: name})
	- when value < min do
	+ def message(%{reason: :minimum, length: min, value: value, name: name})
	+ when value < min do
	gettext("%{name} - %{value} is smaller than inclusive minimum %{min}.",
	name: name,
	value: value,
	min: min
	)
	end

	- defp message(%{reason: :invalid_type, type: type, value: value, name: name}) do
	+ def message(%{reason: :invalid_type, type: type, value: value, name: name}) do
	gettext("%{name} - Invalid %{type}. Got: %{value}.",
	name: name,
	value: OpenApiSpex.TermType.type(value),
	type: type
	)
	end

	- defp message(%{reason: :invalid_format, format: format, name: name}) do
	+ def message(%{reason: :invalid_format, format: format, name: name}) do
	gettext("%{name} - Invalid format. Expected %{format}.", name: name, format: inspect(format))
	end

	- defp message(%{reason: :invalid_enum, name: name}) do
	+ def message(%{reason: :invalid_enum, name: name}) do
	gettext("%{name} - Invalid value for enum.", name: name)
	end

	- defp message(%{reason: :polymorphic_failed, type: polymorphic_type}) do
	+ def message(%{reason: :polymorphic_failed, type: polymorphic_type}) do
	gettext("Failed to cast to any schema in %{polymorphic_type}",
	polymorphic_type: polymorphic_type
	)
	end

	- defp message(%{reason: :unexpected_field, name: name}) do
	+ def message(%{reason: :unexpected_field, name: name}) do
	gettext("Unexpected field: %{name}.", name: safe_string(name))
	end

	- defp message(%{reason: :no_value_for_discriminator, name: field}) do
	+ def message(%{reason: :no_value_for_discriminator, name: field}) do
	gettext("Value used as discriminator for `%{field}` matches no schemas.", name: field)
	end

	- defp message(%{reason: :invalid_discriminator_value, name: field}) do
	+ def message(%{reason: :invalid_discriminator_value, name: field}) do
	gettext("No value provided for required discriminator `%{field}`.", name: field)
	end

	- defp message(%{reason: :unknown_schema, name: name}) do
	+ def message(%{reason: :unknown_schema, name: name}) do
	gettext("Unknown schema: %{name}.", name: name)
	end

	- defp message(%{reason: :missing_field, name: name}) do
	+ def message(%{reason: :missing_field, name: name}) do
	gettext("Missing field: %{name}.", name: name)
	end

	- defp message(%{reason: :missing_header, name: name}) do
	+ def message(%{reason: :missing_header, name: name}) do
	gettext("Missing header: %{name}.", name: name)
	end

	- defp message(%{reason: :invalid_header, name: name}) do
	+ def message(%{reason: :invalid_header, name: name}) do
	gettext("Invalid value for header: %{name}.", name: name)
	end

	- defp message(%{reason: :max_properties, meta: meta}) do
	+ def message(%{reason: :max_properties, meta: meta}) do
	gettext(
	"Object property count %{property_count} is greater than maxProperties: %{max_properties}.",
	property_count: meta.property_count,
	max_properties: meta.max_properties
	)
	end

	- defp message(%{reason: :min_properties, meta: meta}) do
	+ def message(%{reason: :min_properties, meta: meta}) do
	gettext(
	"Object property count %{property_count} is less than minProperties: %{min_properties}",
	property_count: meta.property_count,
	min_properties: meta.min_properties
	)
	end

	defp safe_string(string) do
	to_string(string) \|> String.slice(0..39)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	index 4f9696d52..2047e2439 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	@@ -1,461 +1,476 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [
	add_link_headers: 2,
	truthy_param?: 1,
	assign_account_by_id: 2,
	embed_relationships?: 1,
	json_response: 3
	]

	alias Pleroma.Maps
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	+ alias Pleroma.Web.ApiSpec.Errors.RegistrationUserError
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonAPIController
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OAuth.OAuthController
	alias Pleroma.Web.OAuth.OAuthView
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter
	alias Pleroma.Web.TwitterAPI.TwitterAPI

	- plug(Pleroma.Web.ApiSpec.CastAndValidate)
	+ plug(
	+ Pleroma.Web.ApiSpec.CastAndValidate,
	+ [render_error: RegistrationUserError] when action in [:create]
	+ )
	+
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate when action not in [:create])

	plug(:skip_plug, [OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug] when action == :create)

	plug(:skip_plug, EnsurePublicOrAuthenticatedPlug when action in [:show, :statuses])

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:accounts"]}
	when action in [:show, :followers, :following]
	)

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:statuses"]}
	when action == :statuses
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"]}
	when action in [:verify_credentials, :endorsements, :identity_proofs]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action == :update_credentials)

	plug(OAuthScopesPlug, %{scopes: ["read:lists"]} when action == :lists)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "read:blocks"]} when action == :blocks
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:blocks"]} when action in [:block, :unblock]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:follows"]} when action == :relationships)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:follows"]} when action in [:follow_by_uri, :follow, :unfollow]
	)

	plug(OAuthScopesPlug, %{scopes: ["follow", "read:mutes"]} when action == :mutes)

	plug(OAuthScopesPlug, %{scopes: ["follow", "write:mutes"]} when action in [:mute, :unmute])

	@relationship_actions [:follow, :unfollow]
	@needs_account ~W(followers following lists follow unfollow mute unmute block unblock)a

	plug(
	RateLimiter,
	[name: :relation_id_action, params: [:id, :uri]] when action in @relationship_actions
	)

	plug(RateLimiter, [name: :relations_actions] when action in @relationship_actions)
	plug(RateLimiter, [name: :app_account_creation] when action == :create)
	plug(:assign_account_by_id when action in @needs_account)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.AccountOperation

	@doc "POST /api/v1/accounts"
	def create(%{assigns: %{app: app}, body_params: params} = conn, _params) do
	with :ok <- validate_email_param(params),
	:ok <- TwitterAPI.validate_captcha(app, params),
	{:ok, user} <- TwitterAPI.register_user(params),
	- {_, {:ok, token}} <-
	- {:login, OAuthController.login(user, app, app.scopes)} do
	+ {_, {:ok, token}} <- {:login, OAuthController.login(user, app, app.scopes)} do
	json(conn, OAuthView.render("token.json", %{user: user, token: token}))
	else
	{:login, {:account_status, :confirmation_pending}} ->
	json_response(conn, :ok, %{
	message: "You have been registered. Please check your email for further instructions.",
	identifier: "missing_confirmed_email"
	})

	{:login, {:account_status, :approval_pending}} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. You'll be able to log in once your account is approved.",
	identifier: "awaiting_approval"
	})

	{:login, _} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. Some post-registration steps may be pending. " <>
	"Please log in manually.",
	identifier: "manual_login_required"
	})

	- {:error, error} ->
	- json_response(conn, :bad_request, %{error: error})
	+ {:error, errors} ->
	+ json_response(conn, :bad_request, %{
	+ identifier: "review_submission",
	+ error: "Please review the submission",
	+ fields: errors
	+ })
	end
	end

	def create(%{assigns: %{app: _app}} = conn, _) do
	render_error(conn, :bad_request, "Missing parameters")
	end

	def create(conn, _) do
	render_error(conn, :forbidden, "Invalid credentials")
	end

	defp validate_email_param(%{email: email}) when not is_nil(email), do: :ok

	defp validate_email_param(_) do
	case Pleroma.Config.get([:instance, :account_activation_required]) do
	- true -> {:error, dgettext("errors", "Missing parameter: %{name}", name: "email")}
	- _ -> :ok
	+ true ->
	+ {:error,
	+ %{
	+ email: [dgettext("errors", "Missing parameter: %{name}", name: "email")]
	+ }}
	+
	+ _ ->
	+ :ok
	end
	end

	@doc "GET /api/v1/accounts/verify_credentials"
	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	chat_token = Phoenix.Token.sign(conn, "user socket", user.id)

	render(conn, "show.json",
	user: user,
	for: user,
	with_pleroma_settings: true,
	with_chat_token: chat_token
	)
	end

	@doc "PATCH /api/v1/accounts/update_credentials"
	def update_credentials(%{assigns: %{user: user}, body_params: params} = conn, _params) do
	params =
	params
	\|> Enum.filter(fn {_, value} -> not is_nil(value) end)
	\|> Enum.into(%{})

	# We use an empty string as a special value to reset
	# avatars, banners, backgrounds
	user_image_value = fn
	"" -> {:ok, nil}
	value -> {:ok, value}
	end

	user_params =
	[
	:no_rich_text,
	:locked,
	:hide_followers_count,
	:hide_follows_count,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment,
	:allow_following_move,
	:discoverable,
	:accepts_chat_messages
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	Maps.put_if_present(acc, key, params[key], &{:ok, truthy_param?(&1)})
	end)
	\|> Maps.put_if_present(:name, params[:display_name])
	\|> Maps.put_if_present(:bio, params[:note])
	\|> Maps.put_if_present(:raw_bio, params[:note])
	\|> Maps.put_if_present(:avatar, params[:avatar], user_image_value)
	\|> Maps.put_if_present(:banner, params[:header], user_image_value)
	\|> Maps.put_if_present(:background, params[:pleroma_background_image], user_image_value)
	\|> Maps.put_if_present(
	:raw_fields,
	params[:fields_attributes],
	&{:ok, normalize_fields_attributes(&1)}
	)
	\|> Maps.put_if_present(:pleroma_settings_store, params[:pleroma_settings_store])
	\|> Maps.put_if_present(:default_scope, params[:default_scope])
	\|> Maps.put_if_present(:default_scope, params["source"]["privacy"])
	\|> Maps.put_if_present(:actor_type, params[:bot], fn bot ->
	if bot, do: {:ok, "Service"}, else: {:ok, "Person"}
	end)
	\|> Maps.put_if_present(:actor_type, params[:actor_type])

	# What happens here:
	#
	# We want to update the user through the pipeline, but the ActivityPub
	# update information is not quite enough for this, because this also
	# contains local settings that don't federate and don't even appear
	# in the Update activity.
	#
	# So we first build the normal local changeset, then apply it to the
	# user data, but don't persist it. With this, we generate the object
	# data for our update activity. We feed this and the changeset as meta
	# inforation into the pipeline, where they will be properly updated and
	# federated.
	with changeset <- User.update_changeset(user, user_params),
	{:ok, unpersisted_user} <- Ecto.Changeset.apply_action(changeset, :update),
	updated_object <-
	Pleroma.Web.ActivityPub.UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context"),
	{:ok, update_data, []} <- Builder.update(user, updated_object),
	{:ok, _update, _} <-
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	) do
	render(conn, "show.json",
	user: unpersisted_user,
	for: unpersisted_user,
	with_pleroma_settings: true
	)
	else
	_e -> render_error(conn, :forbidden, "Invalid request")
	end
	end

	defp normalize_fields_attributes(fields) do
	if Enum.all?(fields, &is_tuple/1) do
	Enum.map(fields, fn {_, v} -> v end)
	else
	Enum.map(fields, fn
	%{} = field -> %{"name" => field.name, "value" => field.value}
	field -> field
	end)
	end
	end

	@doc "GET /api/v1/accounts/relationships"
	def relationships(%{assigns: %{user: user}} = conn, %{id: id}) do
	targets = User.get_all_by_ids(List.wrap(id))

	render(conn, "relationships.json", user: user, targets: targets)
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	@doc "GET /api/v1/accounts/:id"
	def show(%{assigns: %{user: for_user}} = conn, %{id: nickname_or_id}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
	:visible <- User.visible_for(user, for_user) do
	render(conn, "show.json", user: user, for: for_user)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	@doc "GET /api/v1/accounts/:id/statuses"
	def statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params.id, for: reading_user),
	:visible <- User.visible_for(user, reading_user) do
	params =
	params
	\|> Map.delete(:tagged)
	\|> Map.put(:tag, params[:tagged])

	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: reading_user,
	as: :activity
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	defp user_visibility_error(conn, error) do
	case error do
	:restrict_unauthenticated ->
	render_error(conn, :unauthorized, "This API requires an authenticated user")

	_ ->
	render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/followers"
	def followers(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_followers(user, params)
	user.hide_followers -> []
	true -> MastodonAPI.get_followers(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/following"
	def following(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_friends(user, params)
	user.hide_follows -> []
	true -> MastodonAPI.get_friends(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/lists"
	def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
	lists = Pleroma.List.get_lists_account_belongs(user, account)

	conn
	\|> put_view(ListView)
	\|> render("index.json", lists: lists)
	end

	@doc "POST /api/v1/accounts/:id/follow"
	def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not follow yourself"}
	end

	def follow(%{body_params: params, assigns: %{user: follower, account: followed}} = conn, _) do
	with {:ok, follower} <- MastodonAPI.follow(follower, followed, params) do
	render(conn, "relationship.json", user: follower, target: followed)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unfollow"
	def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def unfollow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	render(conn, "relationship.json", user: follower, target: followed)
	end
	end

	@doc "POST /api/v1/accounts/:id/mute"
	def mute(%{assigns: %{user: muter, account: muted}, body_params: params} = conn, _params) do
	with {:ok, _user_relationships} <- User.mute(muter, muted, params.notifications) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unmute"
	def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
	with {:ok, _user_relationships} <- User.unmute(muter, muted) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/block"
	def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _activity} <- CommonAPI.block(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unblock"
	def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _activity} <- CommonAPI.unblock(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/follows"
	def follow_by_uri(%{body_params: %{uri: uri}} = conn, _) do
	case User.get_cached_by_nickname(uri) do
	%User{} = user ->
	conn
	\|> assign(:account, user)
	\|> follow(%{})

	nil ->
	{:error, :not_found}
	end
	end

	@doc "GET /api/v1/mutes"
	def mutes(%{assigns: %{user: user}} = conn, _) do
	users = User.muted_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/blocks"
	def blocks(%{assigns: %{user: user}} = conn, _) do
	users = User.blocked_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/endorsements"
	def endorsements(conn, params), do: MastodonAPIController.empty_array(conn, params)

	@doc "GET /api/v1/identity_proofs"
	def identity_proofs(conn, params), do: MastodonAPIController.empty_array(conn, params)
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 5d7948507..92b071a81 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,142 +1,119 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	- import Pleroma.Web.Gettext
	-
	alias Pleroma.Emails.Mailer
	alias Pleroma.Emails.UserEmail
	- alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken

	+ @spec register_user(map(), keyword()) :: {:ok, User.t()} \| {:error, map()}
	def register_user(params, opts \\ []) do
	params =
	params
	\|> Map.take([:email, :token, :password])
	\|> Map.put(:bio, params \|> Map.get(:bio, "") \|> User.parse_bio())
	\|> Map.put(:nickname, params[:username])
	\|> Map.put(:name, Map.get(params, :fullname, params[:username]))
	\|> Map.put(:password_confirmation, params[:password])
	\|> Map.put(:registration_reason, params[:reason])

	if Pleroma.Config.get([:instance, :registrations_open]) do
	create_user(params, opts)
	else
	create_user_with_invite(params, opts)
	end
	end

	+ @spec create_user_with_invite(map(), keyword()) :: {:ok, User.t()} \| {:error, map()}
	defp create_user_with_invite(params, opts) do
	with %{token: token} when is_binary(token) <- params,
	- %UserInviteToken{} = invite <- Repo.get_by(UserInviteToken, %{token: token}),
	+ {:ok, invite} <- UserInviteToken.find_by_token(token),
	true <- UserInviteToken.valid_invite?(invite) do
	UserInviteToken.update_usage!(invite)
	create_user(params, opts)
	else
	- nil -> {:error, "Invalid token"}
	- _ -> {:error, "Expired token"}
	+ nil -> {:error, %{invite: ["Invalid token"]}}
	+ _ -> {:error, %{invite: ["Expired token"]}}
	end
	end

	+ @spec create_user(map(), keyword()) :: {:ok, User.t()} \| {:error, map()}
	defp create_user(params, opts) do
	changeset = User.register_changeset(%User{}, params, opts)

	case User.register(changeset) do
	{:ok, user} ->
	maybe_notify_admins(user)
	{:ok, user}

	{:error, changeset} ->
	errors =
	changeset
	\|> Ecto.Changeset.traverse_errors(fn {msg, _opts} -> msg end)
	- \|> Jason.encode!()

	{:error, errors}
	end
	end

	defp maybe_notify_admins(%User{} = account) do
	if Pleroma.Config.get([:instance, :account_approval_required]) do
	User.all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(account)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)
	end
	end

	def password_reset(nickname_or_email) do
	with true <- is_binary(nickname_or_email),
	%User{local: true, email: email, deactivated: false} = user when is_binary(email) <-
	User.get_by_nickname_or_email(nickname_or_email),
	{:ok, token_record} <- Pleroma.PasswordResetToken.create_token(user) do
	user
	\|> UserEmail.password_reset_email(token_record.token)
	\|> Mailer.deliver_async()

	{:ok, :enqueued}
	else
	_ ->
	{:ok, :noop}
	end
	end

	def validate_captcha(app, params) do
	if app.trusted \|\| not Pleroma.Captcha.enabled?() do
	:ok
	else
	do_validate_captcha(params)
	end
	end

	defp do_validate_captcha(params) do
	with :ok <- validate_captcha_presence(params),
	:ok <-
	Pleroma.Captcha.validate(
	params[:captcha_token],
	params[:captcha_solution],
	params[:captcha_answer_data]
	) do
	:ok
	else
	- {:error, :captcha_error} ->
	- captcha_error(dgettext("errors", "CAPTCHA Error"))
	-
	- {:error, :invalid} ->
	- captcha_error(dgettext("errors", "Invalid CAPTCHA"))
	-
	- {:error, :kocaptcha_service_unavailable} ->
	- captcha_error(dgettext("errors", "Kocaptcha service unavailable"))
	-
	- {:error, :expired} ->
	- captcha_error(dgettext("errors", "CAPTCHA expired"))
	-
	- {:error, :already_used} ->
	- captcha_error(dgettext("errors", "CAPTCHA already used"))
	-
	- {:error, :invalid_answer_data} ->
	- captcha_error(dgettext("errors", "Invalid answer data"))
	-
	{:error, error} ->
	- captcha_error(error)
	+ {:error, %{captcha: [Pleroma.Captcha.Error.message(error)]}}
	end
	end

	defp validate_captcha_presence(params) do
	[:captcha_solution, :captcha_token, :captcha_answer_data]
	\|> Enum.find_value(:ok, fn key ->
	unless is_binary(params[key]) do
	- error = dgettext("errors", "Invalid CAPTCHA (Missing parameter: %{name})", name: key)
	- {:error, error}
	+ {:error, Pleroma.Captcha.Error.message(:missing_field, %{name: key})}
	end
	end)
	end
	-
	- # For some reason FE expects error message to be a serialized JSON
	- defp captcha_error(error), do: {:error, Jason.encode!(%{captcha: [error]})}
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	index f7f1369e4..69b5c6fb7 100644
	--- a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	@@ -1,1536 +1,997 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
	use Pleroma.Web.ConnCase

	- alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.CommonAPI
	- alias Pleroma.Web.OAuth.Token

	import Pleroma.Factory

	describe "account fetching" do
	test "works by id" do
	%User{id: user_id} = insert(:user)

	assert %{"id" => ^user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Can't find user"} =
	build_conn()
	\|> get("/api/v1/accounts/-1")
	\|> json_response_and_validate_schema(404)
	end

	test "works by nickname" do
	user = insert(:user)

	assert %{"id" => user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname for remote users" do
	clear_config([:instance, :limit_to_local_content], false)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert %{"id" => user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "respects limit_to_local_content == :all for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :all)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects limit_to_local_content == :unauthenticated for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)

	user = insert(:user, nickname: "user@example.com", local: false)
	reading_user = insert(:user)

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

	assert json_response_and_validate_schema(conn, 404)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	acc_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")
	\|> json_response_and_validate_schema(:ok)

	acc_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")
	\|> json_response_and_validate_schema(:ok)

	acc_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")
	\|> json_response_and_validate_schema(:ok)

	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for internal.fetch actor", %{conn: conn} do
	%User{nickname: "internal.fetch"} = InternalFetchActor.get_actor()

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/internal.fetch")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for deactivated user", %{conn: conn} do
	user = insert(:user, deactivated: true)

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	end

	defp local_and_remote_users do
	local = insert(:user)
	remote = insert(:user, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "user fetching with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

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

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user timelines" do
	setup do: oauth_access(["read:statuses"])

	test "works with announces that are just addressed to public", %{conn: conn} do
	user = insert(:user, ap_id: "https://honktest/u/test", local: false)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})

	{:ok, announce, _} =
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://honktest/u/test",
	"id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
	"object" => post.data["object"],
	"published" => "2019-06-25T19:33:58Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Announce"
	}
	\|> ActivityPub.persist(local: false)

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

	assert [%{"id" => id}] = resp
	assert id == announce.id
	end

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

	assert %{"error" => "Can't find user"} ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(:not_found)
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects blocks", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	user_three = insert(:user)

	User.block(user_one, user_two)

	{:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
	{:ok, repeat} = CommonAPI.repeat(activity.id, user_three)

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

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Even a blocked user will deliver the full user timeline, there would be
	# no point in looking at a blocked users timeline otherwise
	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Third user's timeline includes the repeat when viewed by unauthenticated user
	resp =
	build_conn()
	\|> get("/api/v1/accounts/#{user_three.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == repeat.id

	# When viewing a third user's timeline, the blocked users' statuses will NOT be shown
	resp = get(conn, "/api/v1/accounts/#{user_three.id}/statuses")

	assert [] == json_response_and_validate_schema(resp, 200)
	end

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

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

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

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

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

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

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

	resp =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

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

	resp =
	conn
	\|> assign(:user, user_three)
	\|> assign(:token, insert(:oauth_token, user: user_three, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

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

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

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

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

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

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

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: other_user.ap_id)

	{:ok, %{id: other_image_post_id}} =
	CommonAPI.post(other_user, %{status: "cofe2", media_ids: [media_id]})

	{:ok, _announce} = CommonAPI.repeat(other_image_post_id, user)

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

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)

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

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, _} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=1")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
	{:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "the user views their own timelines and excludes direct messages", %{
	user: user,
	conn: conn
	} do
	{:ok, %{id: public_activity_id}} =
	CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
	assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
	end
	end

	defp local_and_remote_activities(%{local: local, remote: remote}) do
	insert(:note_activity, user: local)
	insert(:note_activity, user: remote, local: false)

	:ok
	end

	describe "statuses with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "followers" do
	setup do: oauth_access(["read:accounts"])

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

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

	assert [%{"id" => ^user_id}] = json_response_and_validate_schema(conn, 200)
	end

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

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

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

	test "getting followers, hide_followers, same user requesting" do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)
	{:ok, _user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, pagination", %{user: user, conn: conn} do
	{:ok, %User{id: follower1_id}} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower2_id}} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower3_id}} = :user \|> insert() \|> User.follow(user)

	assert [%{"id" => ^follower3_id}, %{"id" => ^follower2_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get(
	"/api/v1/accounts/#{user.id}/followers?id=#{user.id}&limit=20&max_id=#{
	follower3_id
	}"
	)
	\|> json_response_and_validate_schema(200)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3_id}")

	assert [%{"id" => ^follower2_id}] = json_response_and_validate_schema(res_conn, 200)

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2_id}/
	assert link_header =~ ~r/max_id=#{follower2_id}/
	end
	end

	describe "following" do
	setup do: oauth_access(["read:accounts"])

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

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

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

	test "getting following, hide_follows, other user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

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

	test "getting following, hide_follows, same user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, pagination", %{user: user, conn: conn} do
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _} = User.follow(user, following1)
	{:ok, _} = User.follow(user, following2)
	{:ok, _} = User.follow(user, following3)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(
	conn,
	"/api/v1/accounts/#{user.id}/following?id=#{user.id}&limit=20&max_id=#{following3.id}"
	)

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(conn, "/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end
	end

	describe "follow/unfollow" do
	setup do: oauth_access(["follow"])

	test "following / unfollowing a user", %{conn: conn} do
	%{id: other_user_id, nickname: other_user_nickname} = insert(:user)

	assert %{"id" => _id, "following" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => _id, "following" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^other_user_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/follows", %{"uri" => other_user_nickname})
	\|> json_response_and_validate_schema(200)
	end

	test "cancelling follow request", %{conn: conn} do
	%{id: other_user_id} = insert(:user, %{locked: true})

	assert %{"id" => ^other_user_id, "following" => false, "requested" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(:ok)

	assert %{"id" => ^other_user_id, "following" => false, "requested" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(:ok)
	end

	test "following without reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})

	assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: true})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response(200)
	end

	test "following with reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{followed.id}/follow")

	assert %{"showing_reblogs" => true} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})
	\|> json_response_and_validate_schema(200)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response(200)
	end

	test "following / unfollowing errors", %{user: user, conn: conn} do
	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")

	assert %{"error" => "Can not follow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self follow via uri
	user = User.get_cached_by_id(user.id)

	assert %{"error" => "Can not follow yourself"} =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => user.nickname})
	\|> json_response_and_validate_schema(400)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# follow non existing user via uri
	conn_res =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => "doesntexist"})

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end

	describe "mute/unmute" do
	setup do: oauth_access(["write:mutes"])

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

	assert %{"id" => _id, "muting" => true, "muting_notifications" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user.id}/mute")
	\|> json_response_and_validate_schema(200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

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

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"notifications" => "false"})

	assert %{"id" => _id, "muting" => true, "muting_notifications" => false} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end
	end

	describe "pinned statuses" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
	%{conn: conn} = oauth_access(["read:statuses"], user: user)

	[conn: conn, user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: %{id: activity_id}} do
	{:ok, _} = CommonAPI.pin(activity_id, user)

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "blocking / unblocking a user" do
	%{conn: conn} = oauth_access(["follow"])
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unblock")

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

	- describe "create account by app" do
	- setup do
	- valid_params = %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true
	- }
	-
	- [valid_params: valid_params]
	- end
	-
	- test "registers and logs in without :account_activation_required / :account_approval_required",
	- %{conn: conn} do
	- clear_config([:instance, :account_activation_required], false)
	- clear_config([:instance, :account_approval_required], false)
	-
	- conn =
	- conn
	- \|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/apps", %{
	- client_name: "client_name",
	- redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	- scopes: "read, write, follow"
	- })
	-
	- assert %{
	- "client_id" => client_id,
	- "client_secret" => client_secret,
	- "id" => _,
	- "name" => "client_name",
	- "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	- "vapid_key" => _,
	- "website" => nil
	- } = json_response_and_validate_schema(conn, 200)
	-
	- conn =
	- post(conn, "/oauth/token", %{
	- grant_type: "client_credentials",
	- client_id: client_id,
	- client_secret: client_secret
	- })
	-
	- assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	- json_response(conn, 200)
	-
	- assert token
	- token_from_db = Repo.get_by(Token, token: token)
	- assert token_from_db
	- assert refresh
	- assert scope == "read write follow"
	-
	- clear_config([User, :email_blacklist], ["example.org"])
	-
	- params = %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- bio: "Test Bio",
	- agreement: true
	- }
	-
	- conn =
	- build_conn()
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> put_req_header("authorization", "Bearer " <> token)
	- \|> post("/api/v1/accounts", params)
	-
	- assert %{"error" => "{\"email\":[\"Invalid email\"]}"} =
	- json_response_and_validate_schema(conn, 400)
	-
	- Pleroma.Config.put([User, :email_blacklist], [])
	-
	- conn =
	- build_conn()
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> put_req_header("authorization", "Bearer " <> token)
	- \|> post("/api/v1/accounts", params)
	-
	- %{
	- "access_token" => token,
	- "created_at" => _created_at,
	- "scope" => ^scope,
	- "token_type" => "Bearer"
	- } = json_response_and_validate_schema(conn, 200)
	-
	- token_from_db = Repo.get_by(Token, token: token)
	- assert token_from_db
	- user = Repo.preload(token_from_db, :user).user
	-
	- assert user
	- refute user.confirmation_pending
	- refute user.approval_pending
	- end
	-
	- test "registers but does not log in with :account_activation_required", %{conn: conn} do
	- clear_config([:instance, :account_activation_required], true)
	- clear_config([:instance, :account_approval_required], false)
	-
	- conn =
	- conn
	- \|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/apps", %{
	- client_name: "client_name",
	- redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	- scopes: "read, write, follow"
	- })
	-
	- assert %{
	- "client_id" => client_id,
	- "client_secret" => client_secret,
	- "id" => _,
	- "name" => "client_name",
	- "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	- "vapid_key" => _,
	- "website" => nil
	- } = json_response_and_validate_schema(conn, 200)
	-
	- conn =
	- post(conn, "/oauth/token", %{
	- grant_type: "client_credentials",
	- client_id: client_id,
	- client_secret: client_secret
	- })
	-
	- assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	- json_response(conn, 200)
	-
	- assert token
	- token_from_db = Repo.get_by(Token, token: token)
	- assert token_from_db
	- assert refresh
	- assert scope == "read write follow"
	-
	- conn =
	- build_conn()
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> put_req_header("authorization", "Bearer " <> token)
	- \|> post("/api/v1/accounts", %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- bio: "Test Bio",
	- agreement: true
	- })
	-
	- response = json_response_and_validate_schema(conn, 200)
	- assert %{"identifier" => "missing_confirmed_email"} = response
	- refute response["access_token"]
	- refute response["token_type"]
	-
	- user = Repo.get_by(User, email: "lain@example.org")
	- assert user.confirmation_pending
	- end
	-
	- test "registers but does not log in with :account_approval_required", %{conn: conn} do
	- clear_config([:instance, :account_approval_required], true)
	- clear_config([:instance, :account_activation_required], false)
	-
	- conn =
	- conn
	- \|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/apps", %{
	- client_name: "client_name",
	- redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	- scopes: "read, write, follow"
	- })
	-
	- assert %{
	- "client_id" => client_id,
	- "client_secret" => client_secret,
	- "id" => _,
	- "name" => "client_name",
	- "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	- "vapid_key" => _,
	- "website" => nil
	- } = json_response_and_validate_schema(conn, 200)
	-
	- conn =
	- post(conn, "/oauth/token", %{
	- grant_type: "client_credentials",
	- client_id: client_id,
	- client_secret: client_secret
	- })
	-
	- assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	- json_response(conn, 200)
	-
	- assert token
	- token_from_db = Repo.get_by(Token, token: token)
	- assert token_from_db
	- assert refresh
	- assert scope == "read write follow"
	-
	- conn =
	- build_conn()
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> put_req_header("authorization", "Bearer " <> token)
	- \|> post("/api/v1/accounts", %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- bio: "Test Bio",
	- agreement: true,
	- reason: "I'm a cool dude, bro"
	- })
	-
	- response = json_response_and_validate_schema(conn, 200)
	- assert %{"identifier" => "awaiting_approval"} = response
	- refute response["access_token"]
	- refute response["token_type"]
	-
	- user = Repo.get_by(User, email: "lain@example.org")
	-
	- assert user.approval_pending
	- assert user.registration_reason == "I'm a cool dude, bro"
	- end
	-
	- test "returns error when user already registred", %{conn: conn, valid_params: valid_params} do
	- _user = insert(:user, email: "lain@example.org")
	- app_token = insert(:oauth_token, user: nil)
	-
	- res =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> app_token.token)
	- \|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/accounts", valid_params)
	-
	- assert json_response_and_validate_schema(res, 400) == %{
	- "error" => "{\"email\":[\"has already been taken\"]}"
	- }
	- end
	-
	- test "returns bad_request if missing required params", %{
	- conn: conn,
	- valid_params: valid_params
	- } do
	- app_token = insert(:oauth_token, user: nil)
	-
	- conn =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> app_token.token)
	- \|> put_req_header("content-type", "application/json")
	-
	- res = post(conn, "/api/v1/accounts", valid_params)
	- assert json_response_and_validate_schema(res, 200)
	-
	- [{127, 0, 0, 1}, {127, 0, 0, 2}, {127, 0, 0, 3}, {127, 0, 0, 4}]
	- \|> Stream.zip(Map.delete(valid_params, :email))
	- \|> Enum.each(fn {ip, {attr, _}} ->
	- res =
	- conn
	- \|> Map.put(:remote_ip, ip)
	- \|> post("/api/v1/accounts", Map.delete(valid_params, attr))
	- \|> json_response_and_validate_schema(400)
	-
	- assert res == %{
	- "error" => "Missing field: #{attr}.",
	- "errors" => [
	- %{
	- "message" => "Missing field: #{attr}",
	- "source" => %{"pointer" => "/#{attr}"},
	- "title" => "Invalid value"
	- }
	- ]
	- }
	- end)
	- end
	-
	- test "returns bad_request if missing email params when :account_activation_required is enabled",
	- %{conn: conn, valid_params: valid_params} do
	- clear_config([:instance, :account_activation_required], true)
	-
	- app_token = insert(:oauth_token, user: nil)
	-
	- conn =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> app_token.token)
	- \|> put_req_header("content-type", "application/json")
	-
	- res =
	- conn
	- \|> Map.put(:remote_ip, {127, 0, 0, 5})
	- \|> post("/api/v1/accounts", Map.delete(valid_params, :email))
	-
	- assert json_response_and_validate_schema(res, 400) ==
	- %{"error" => "Missing parameter: email"}
	-
	- res =
	- conn
	- \|> Map.put(:remote_ip, {127, 0, 0, 6})
	- \|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))
	-
	- assert json_response_and_validate_schema(res, 400) == %{
	- "error" => "{\"email\":[\"can't be blank\"]}"
	- }
	- end
	-
	- test "allow registration without an email", %{conn: conn, valid_params: valid_params} do
	- app_token = insert(:oauth_token, user: nil)
	- conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)
	-
	- res =
	- conn
	- \|> put_req_header("content-type", "application/json")
	- \|> Map.put(:remote_ip, {127, 0, 0, 7})
	- \|> post("/api/v1/accounts", Map.delete(valid_params, :email))
	-
	- assert json_response_and_validate_schema(res, 200)
	- end
	-
	- test "allow registration with an empty email", %{conn: conn, valid_params: valid_params} do
	- app_token = insert(:oauth_token, user: nil)
	- conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)
	-
	- res =
	- conn
	- \|> put_req_header("content-type", "application/json")
	- \|> Map.put(:remote_ip, {127, 0, 0, 8})
	- \|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))
	-
	- assert json_response_and_validate_schema(res, 200)
	- end
	-
	- test "returns forbidden if token is invalid", %{conn: conn, valid_params: valid_params} do
	- res =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> "invalid-token")
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/v1/accounts", valid_params)
	-
	- assert json_response_and_validate_schema(res, 403) == %{"error" => "Invalid credentials"}
	- end
	-
	- test "registration from trusted app" do
	- clear_config([Pleroma.Captcha, :enabled], true)
	- app = insert(:oauth_app, trusted: true, scopes: ["read", "write", "follow", "push"])
	-
	- conn =
	- build_conn()
	- \|> post("/oauth/token", %{
	- "grant_type" => "client_credentials",
	- "client_id" => app.client_id,
	- "client_secret" => app.client_secret
	- })
	-
	- assert %{"access_token" => token, "token_type" => "Bearer"} = json_response(conn, 200)
	-
	- response =
	- build_conn()
	- \|> Plug.Conn.put_req_header("authorization", "Bearer " <> token)
	- \|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/v1/accounts", %{
	- nickname: "nickanme",
	- agreement: true,
	- email: "email@example.com",
	- fullname: "Lain",
	- username: "Lain",
	- password: "some_password",
	- confirm: "some_password"
	- })
	- \|> json_response_and_validate_schema(200)
	-
	- assert %{
	- "access_token" => access_token,
	- "created_at" => _,
	- "scope" => "read write follow push",
	- "token_type" => "Bearer"
	- } = response
	-
	- response =
	- build_conn()
	- \|> Plug.Conn.put_req_header("authorization", "Bearer " <> access_token)
	- \|> get("/api/v1/accounts/verify_credentials")
	- \|> json_response_and_validate_schema(200)
	-
	- assert %{
	- "acct" => "Lain",
	- "bot" => false,
	- "display_name" => "Lain",
	- "follow_requests_count" => 0,
	- "followers_count" => 0,
	- "following_count" => 0,
	- "locked" => false,
	- "note" => "",
	- "source" => %{
	- "fields" => [],
	- "note" => "",
	- "pleroma" => %{
	- "actor_type" => "Person",
	- "discoverable" => false,
	- "no_rich_text" => false,
	- "show_role" => true
	- },
	- "privacy" => "public",
	- "sensitive" => false
	- },
	- "statuses_count" => 0,
	- "username" => "Lain"
	- } = response
	- end
	- end
	-
	- describe "create account by app / rate limit" do
	- setup do: clear_config([:rate_limit, :app_account_creation], {10_000, 2})
	-
	- test "respects rate limit setting", %{conn: conn} do
	- app_token = insert(:oauth_token, user: nil)
	-
	- conn =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> app_token.token)
	- \|> Map.put(:remote_ip, {15, 15, 15, 15})
	- \|> put_req_header("content-type", "multipart/form-data")
	-
	- for i <- 1..2 do
	- conn =
	- conn
	- \|> post("/api/v1/accounts", %{
	- username: "#{i}lain",
	- email: "#{i}lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true
	- })
	-
	- %{
	- "access_token" => token,
	- "created_at" => _created_at,
	- "scope" => _scope,
	- "token_type" => "Bearer"
	- } = json_response_and_validate_schema(conn, 200)
	-
	- token_from_db = Repo.get_by(Token, token: token)
	- assert token_from_db
	- token_from_db = Repo.preload(token_from_db, :user)
	- assert token_from_db.user
	- end
	-
	- conn =
	- post(conn, "/api/v1/accounts", %{
	- username: "6lain",
	- email: "6lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true
	- })
	-
	- assert json_response_and_validate_schema(conn, :too_many_requests) == %{
	- "error" => "Throttled"
	- }
	- end
	- end
	-
	- describe "create account with enabled captcha" do
	- setup %{conn: conn} do
	- app_token = insert(:oauth_token, user: nil)
	-
	- conn =
	- conn
	- \|> put_req_header("authorization", "Bearer " <> app_token.token)
	- \|> put_req_header("content-type", "multipart/form-data")
	-
	- [conn: conn]
	- end
	-
	- setup do: clear_config([Pleroma.Captcha, :enabled], true)
	-
	- test "creates an account and returns 200 if captcha is valid", %{conn: conn} do
	- %{token: token, answer_data: answer_data} = Pleroma.Captcha.new()
	-
	- params = %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true,
	- captcha_solution: Pleroma.Captcha.Mock.solution(),
	- captcha_token: token,
	- captcha_answer_data: answer_data
	- }
	-
	- assert %{
	- "access_token" => access_token,
	- "created_at" => _,
	- "scope" => "read",
	- "token_type" => "Bearer"
	- } =
	- conn
	- \|> post("/api/v1/accounts", params)
	- \|> json_response_and_validate_schema(:ok)
	-
	- assert Token \|> Repo.get_by(token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	-
	- Cachex.del(:used_captcha_cache, token)
	- end
	-
	- test "returns 400 if any captcha field is not provided", %{conn: conn} do
	- captcha_fields = [:captcha_solution, :captcha_token, :captcha_answer_data]
	-
	- valid_params = %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true,
	- captcha_solution: "xx",
	- captcha_token: "xx",
	- captcha_answer_data: "xx"
	- }
	-
	- for field <- captcha_fields do
	- expected = %{
	- "error" => "{\"captcha\":[\"Invalid CAPTCHA (Missing parameter: #{field})\"]}"
	- }
	-
	- assert expected ==
	- conn
	- \|> post("/api/v1/accounts", Map.delete(valid_params, field))
	- \|> json_response_and_validate_schema(:bad_request)
	- end
	- end
	-
	- test "returns an error if captcha is invalid", %{conn: conn} do
	- params = %{
	- username: "lain",
	- email: "lain@example.org",
	- password: "PlzDontHackLain",
	- agreement: true,
	- captcha_solution: "cofe",
	- captcha_token: "cofe",
	- captcha_answer_data: "cofe"
	- }
	-
	- assert %{"error" => "{\"captcha\":[\"Invalid answer data\"]}"} ==
	- conn
	- \|> post("/api/v1/accounts", params)
	- \|> json_response_and_validate_schema(:bad_request)
	- end
	- end
	-
	describe "GET /api/v1/accounts/:id/lists - account_lists" do
	test "returns lists to which the account belongs" do
	%{user: user, conn: conn} = oauth_access(["read:lists"])
	other_user = insert(:user)
	assert {:ok, %Pleroma.List{id: list_id} = list} = Pleroma.List.create("Test List", user)
	{:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)

	assert [%{"id" => list_id, "title" => "Test List"}] =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/lists")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "verify_credentials" do
	test "verify_credentials" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	[notification \| _] =
	insert_list(7, :notification, user: user, activity: insert(:note_activity))

	Pleroma.Notification.set_read_up_to(user, notification.id)
	conn = get(conn, "/api/v1/accounts/verify_credentials")

	response = json_response_and_validate_schema(conn, 200)

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = response
	assert response["pleroma"]["chat_token"]
	assert response["pleroma"]["unread_notifications_count"] == 6
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted" do
	user = insert(:user, default_scope: "unlisted")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end

	test "locked accounts" do
	user = insert(:user, default_scope: "private")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} =
	json_response_and_validate_schema(conn, 200)

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

	describe "user relationships" do
	setup do: oauth_access(["read:follows"])

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

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id[]=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns an empty list on a bad request", %{conn: conn} do
	conn = get(conn, "/api/v1/accounts/relationships", %{})

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

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

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

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

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

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

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

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

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response_and_validate_schema(conn, 200)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/registration_user_test.exs b/test/pleroma/web/mastodon_api/registration_user_test.exs
	new file mode 100644
	index 000000000..086d29832
	--- /dev/null
	+++ b/test/pleroma/web/mastodon_api/registration_user_test.exs
	@@ -0,0 +1,691 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MastodonAPI.RegistrationUserTest do
	+ use Pleroma.Web.ConnCase
	+
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+ alias Pleroma.UserInviteToken
	+ alias Pleroma.Web.OAuth.Token
	+
	+ import Pleroma.Factory
	+
	+ describe "create account by app" do
	+ setup do
	+ valid_params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true
	+ }
	+
	+ [valid_params: valid_params]
	+ end
	+
	+ test "registers and logs in without :account_activation_required / :account_approval_required",
	+ %{conn: conn} do
	+ clear_config([:instance, :account_activation_required], false)
	+ clear_config([:instance, :account_approval_required], false)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/apps", %{
	+ client_name: "client_name",
	+ redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	+ scopes: "read, write, follow"
	+ })
	+
	+ assert %{
	+ "client_id" => client_id,
	+ "client_secret" => client_secret,
	+ "id" => _,
	+ "name" => "client_name",
	+ "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	+ "vapid_key" => _,
	+ "website" => nil
	+ } = json_response_and_validate_schema(conn, 200)
	+
	+ conn =
	+ post(conn, "/oauth/token", %{
	+ grant_type: "client_credentials",
	+ client_id: client_id,
	+ client_secret: client_secret
	+ })
	+
	+ assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	+ json_response(conn, 200)
	+
	+ assert token
	+ token_from_db = Repo.get_by(Token, token: token)
	+ assert token_from_db
	+ assert refresh
	+ assert scope == "read write follow"
	+
	+ clear_config([User, :email_blacklist], ["example.org"])
	+
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ bio: "Test Bio",
	+ agreement: true
	+ }
	+
	+ response =
	+ build_conn()
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> put_req_header("authorization", "Bearer " <> token)
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert response == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"email" => ["Invalid email"]},
	+ "identifier" => "review_submission"
	+ }
	+
	+ Pleroma.Config.put([User, :email_blacklist], [])
	+
	+ conn =
	+ build_conn()
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> put_req_header("authorization", "Bearer " <> token)
	+ \|> post("/api/v1/accounts", params)
	+
	+ %{
	+ "access_token" => token,
	+ "created_at" => _created_at,
	+ "scope" => ^scope,
	+ "token_type" => "Bearer"
	+ } = json_response_and_validate_schema(conn, 200)
	+
	+ token_from_db = Repo.get_by(Token, token: token)
	+ assert token_from_db
	+ user = Repo.preload(token_from_db, :user).user
	+
	+ assert user
	+ refute user.confirmation_pending
	+ refute user.approval_pending
	+ end
	+
	+ test "registers but does not log in with :account_activation_required", %{conn: conn} do
	+ clear_config([:instance, :account_activation_required], true)
	+ clear_config([:instance, :account_approval_required], false)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/apps", %{
	+ client_name: "client_name",
	+ redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	+ scopes: "read, write, follow"
	+ })
	+
	+ assert %{
	+ "client_id" => client_id,
	+ "client_secret" => client_secret,
	+ "id" => _,
	+ "name" => "client_name",
	+ "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	+ "vapid_key" => _,
	+ "website" => nil
	+ } = json_response_and_validate_schema(conn, 200)
	+
	+ conn =
	+ post(conn, "/oauth/token", %{
	+ grant_type: "client_credentials",
	+ client_id: client_id,
	+ client_secret: client_secret
	+ })
	+
	+ assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	+ json_response(conn, 200)
	+
	+ assert token
	+ token_from_db = Repo.get_by(Token, token: token)
	+ assert token_from_db
	+ assert refresh
	+ assert scope == "read write follow"
	+
	+ conn =
	+ build_conn()
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> put_req_header("authorization", "Bearer " <> token)
	+ \|> post("/api/v1/accounts", %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ bio: "Test Bio",
	+ agreement: true
	+ })
	+
	+ response = json_response_and_validate_schema(conn, 200)
	+ assert %{"identifier" => "missing_confirmed_email"} = response
	+ refute response["access_token"]
	+ refute response["token_type"]
	+
	+ user = Repo.get_by(User, email: "lain@example.org")
	+ assert user.confirmation_pending
	+ end
	+
	+ test "registers but does not log in with :account_approval_required", %{conn: conn} do
	+ clear_config([:instance, :account_approval_required], true)
	+ clear_config([:instance, :account_activation_required], false)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/apps", %{
	+ client_name: "client_name",
	+ redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	+ scopes: "read, write, follow"
	+ })
	+
	+ assert %{
	+ "client_id" => client_id,
	+ "client_secret" => client_secret,
	+ "id" => _,
	+ "name" => "client_name",
	+ "redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	+ "vapid_key" => _,
	+ "website" => nil
	+ } = json_response_and_validate_schema(conn, 200)
	+
	+ conn =
	+ post(conn, "/oauth/token", %{
	+ grant_type: "client_credentials",
	+ client_id: client_id,
	+ client_secret: client_secret
	+ })
	+
	+ assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	+ json_response(conn, 200)
	+
	+ assert token
	+ token_from_db = Repo.get_by(Token, token: token)
	+ assert token_from_db
	+ assert refresh
	+ assert scope == "read write follow"
	+
	+ conn =
	+ build_conn()
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> put_req_header("authorization", "Bearer " <> token)
	+ \|> post("/api/v1/accounts", %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ bio: "Test Bio",
	+ agreement: true,
	+ reason: "I'm a cool dude, bro"
	+ })
	+
	+ response = json_response_and_validate_schema(conn, 200)
	+ assert %{"identifier" => "awaiting_approval"} = response
	+ refute response["access_token"]
	+ refute response["token_type"]
	+
	+ user = Repo.get_by(User, email: "lain@example.org")
	+
	+ assert user.approval_pending
	+ assert user.registration_reason == "I'm a cool dude, bro"
	+ end
	+
	+ test "returns error when user already registred", %{conn: conn, valid_params: valid_params} do
	+ _user = insert(:user, email: "lain@example.org")
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ res =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/v1/accounts", valid_params)
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"email" => ["has already been taken"]},
	+ "identifier" => "review_submission"
	+ }
	+ end
	+
	+ test "returns bad_request if missing required params", %{
	+ conn: conn,
	+ valid_params: valid_params
	+ } do
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "application/json")
	+
	+ res = post(conn, "/api/v1/accounts", valid_params)
	+ assert json_response_and_validate_schema(res, 200)
	+
	+ [{127, 0, 0, 1}, {127, 0, 0, 2}, {127, 0, 0, 3}, {127, 0, 0, 4}]
	+ \|> Stream.zip(Map.delete(valid_params, :email))
	+ \|> Enum.each(fn {ip, {attr, _}} ->
	+ res =
	+ conn
	+ \|> Map.put(:remote_ip, ip)
	+ \|> post("/api/v1/accounts", Map.delete(valid_params, attr))
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"#{attr}" => ["Missing field: #{attr}."]},
	+ "identifier" => "review_submission"
	+ }
	+ end)
	+ end
	+
	+ test "returns bad_request if missing email params when :account_activation_required is enabled",
	+ %{conn: conn, valid_params: valid_params} do
	+ clear_config([:instance, :account_activation_required], true)
	+
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "application/json")
	+
	+ res =
	+ conn
	+ \|> Map.put(:remote_ip, {127, 0, 0, 5})
	+ \|> post("/api/v1/accounts", Map.delete(valid_params, :email))
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"email" => ["Missing parameter: email"]},
	+ "identifier" => "review_submission"
	+ }
	+
	+ res =
	+ conn
	+ \|> Map.put(:remote_ip, {127, 0, 0, 6})
	+ \|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"email" => ["can't be blank"]},
	+ "identifier" => "review_submission"
	+ }
	+ end
	+
	+ test "allow registration without an email", %{conn: conn, valid_params: valid_params} do
	+ app_token = insert(:oauth_token, user: nil)
	+ conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)
	+
	+ res =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> Map.put(:remote_ip, {127, 0, 0, 7})
	+ \|> post("/api/v1/accounts", Map.delete(valid_params, :email))
	+
	+ assert json_response_and_validate_schema(res, 200)
	+ end
	+
	+ test "allow registration with an empty email", %{conn: conn, valid_params: valid_params} do
	+ app_token = insert(:oauth_token, user: nil)
	+ conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)
	+
	+ res =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> Map.put(:remote_ip, {127, 0, 0, 8})
	+ \|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))
	+
	+ assert json_response_and_validate_schema(res, 200)
	+ end
	+
	+ test "returns forbidden if token is invalid", %{conn: conn, valid_params: valid_params} do
	+ res =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> "invalid-token")
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/v1/accounts", valid_params)
	+
	+ assert json_response_and_validate_schema(res, 403) == %{"error" => "Invalid credentials"}
	+ end
	+
	+ test "registration from trusted app" do
	+ clear_config([Pleroma.Captcha, :enabled], true)
	+ app = insert(:oauth_app, trusted: true, scopes: ["read", "write", "follow", "push"])
	+
	+ conn =
	+ build_conn()
	+ \|> post("/oauth/token", %{
	+ "grant_type" => "client_credentials",
	+ "client_id" => app.client_id,
	+ "client_secret" => app.client_secret
	+ })
	+
	+ assert %{"access_token" => token, "token_type" => "Bearer"} = json_response(conn, 200)
	+
	+ response =
	+ build_conn()
	+ \|> Plug.Conn.put_req_header("authorization", "Bearer " <> token)
	+ \|> put_req_header("content-type", "multipart/form-data")
	+ \|> post("/api/v1/accounts", %{
	+ nickname: "nickanme",
	+ agreement: true,
	+ email: "email@example.com",
	+ fullname: "Lain",
	+ username: "Lain",
	+ password: "some_password",
	+ confirm: "some_password"
	+ })
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert %{
	+ "access_token" => access_token,
	+ "created_at" => _,
	+ "scope" => "read write follow push",
	+ "token_type" => "Bearer"
	+ } = response
	+
	+ response =
	+ build_conn()
	+ \|> Plug.Conn.put_req_header("authorization", "Bearer " <> access_token)
	+ \|> get("/api/v1/accounts/verify_credentials")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert %{
	+ "acct" => "Lain",
	+ "bot" => false,
	+ "display_name" => "Lain",
	+ "follow_requests_count" => 0,
	+ "followers_count" => 0,
	+ "following_count" => 0,
	+ "locked" => false,
	+ "note" => "",
	+ "source" => %{
	+ "fields" => [],
	+ "note" => "",
	+ "pleroma" => %{
	+ "actor_type" => "Person",
	+ "discoverable" => false,
	+ "no_rich_text" => false,
	+ "show_role" => true
	+ },
	+ "privacy" => "public",
	+ "sensitive" => false
	+ },
	+ "statuses_count" => 0,
	+ "username" => "Lain"
	+ } = response
	+ end
	+ end
	+
	+ describe "create account by app / rate limit" do
	+ setup do: clear_config([:rate_limit, :app_account_creation], {10_000, 2})
	+
	+ test "respects rate limit setting", %{conn: conn} do
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> Map.put(:remote_ip, {15, 15, 15, 15})
	+ \|> put_req_header("content-type", "multipart/form-data")
	+
	+ for i <- 1..2 do
	+ conn =
	+ conn
	+ \|> post("/api/v1/accounts", %{
	+ username: "#{i}lain",
	+ email: "#{i}lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true
	+ })
	+
	+ %{
	+ "access_token" => token,
	+ "created_at" => _created_at,
	+ "scope" => _scope,
	+ "token_type" => "Bearer"
	+ } = json_response_and_validate_schema(conn, 200)
	+
	+ token_from_db = Repo.get_by(Token, token: token)
	+ assert token_from_db
	+ token_from_db = Repo.preload(token_from_db, :user)
	+ assert token_from_db.user
	+ end
	+
	+ conn =
	+ post(conn, "/api/v1/accounts", %{
	+ username: "6lain",
	+ email: "6lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true
	+ })
	+
	+ assert json_response_and_validate_schema(conn, :too_many_requests) == %{
	+ "error" => "Throttled"
	+ }
	+ end
	+ end
	+
	+ describe "create account via invite" do
	+ setup %{conn: conn} do
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "multipart/form-data")
	+
	+ [conn: conn]
	+ end
	+
	+ setup do: clear_config([:instance, :registrations_open], false)
	+ setup do: clear_config([Pleroma.Captcha, :enabled], false)
	+
	+ test "creates an account", %{conn: conn} do
	+ invite = insert(:user_invite_token, %{invite_type: "one_time"})
	+
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ token: invite.token
	+ }
	+
	+ res =
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+ assert invite.used == true
	+
	+ assert %{
	+ "access_token" => access_token,
	+ "created_at" => _,
	+ "scope" => "read",
	+ "token_type" => "Bearer"
	+ } = res
	+
	+ user = Repo.get_by(Token, token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	+ assert user.email == "lain@example.org"
	+ end
	+
	+ test "returns error when already used", %{conn: conn} do
	+ invite = insert(:user_invite_token, %{used: true, invite_type: "one_time"})
	+
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ token: invite.token
	+ }
	+
	+ res =
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"invite" => ["Expired token"]},
	+ "identifier" => "review_submission"
	+ }
	+ end
	+
	+ test "returns errors when invite is invalid", %{conn: conn} do
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ token: "fake-token"
	+ }
	+
	+ res =
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(400)
	+
	+ assert res == %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"invite" => ["Invalid token"]},
	+ "identifier" => "review_submission"
	+ }
	+ end
	+ end
	+
	+ describe "create account with enabled captcha" do
	+ setup %{conn: conn} do
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "multipart/form-data")
	+
	+ [conn: conn]
	+ end
	+
	+ setup do: clear_config([Pleroma.Captcha, :enabled], true)
	+
	+ test "creates an account and returns 200 if captcha is valid", %{conn: conn} do
	+ %{token: token, answer_data: answer_data} = Pleroma.Captcha.new()
	+
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ captcha_solution: Pleroma.Captcha.Mock.solution(),
	+ captcha_token: token,
	+ captcha_answer_data: answer_data
	+ }
	+
	+ assert %{
	+ "access_token" => access_token,
	+ "created_at" => _,
	+ "scope" => "read",
	+ "token_type" => "Bearer"
	+ } =
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ assert Token \|> Repo.get_by(token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	+
	+ Cachex.del(:used_captcha_cache, token)
	+ end
	+
	+ test "returns 400 if any captcha field is not provided", %{conn: conn} do
	+ captcha_fields = [:captcha_solution, :captcha_token, :captcha_answer_data]
	+
	+ valid_params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ captcha_solution: "xx",
	+ captcha_token: "xx",
	+ captcha_answer_data: "xx"
	+ }
	+
	+ for field <- captcha_fields do
	+ expected = %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"captcha" => ["Invalid CAPTCHA (Missing parameter: #{field})"]},
	+ "identifier" => "review_submission"
	+ }
	+
	+ assert expected ==
	+ conn
	+ \|> post("/api/v1/accounts", Map.delete(valid_params, field))
	+ \|> json_response_and_validate_schema(:bad_request)
	+ end
	+ end
	+
	+ test "returns an error if captcha is invalid", %{conn: conn} do
	+ params = %{
	+ username: "lain",
	+ email: "lain@example.org",
	+ password: "PlzDontHackLain",
	+ agreement: true,
	+ captcha_solution: "cofe",
	+ captcha_token: "cofe",
	+ captcha_answer_data: "cofe"
	+ }
	+
	+ assert %{
	+ "error" => "Please review the submission",
	+ "fields" => %{"captcha" => ["Invalid answer data"]},
	+ "identifier" => "review_submission"
	+ } ==
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(:bad_request)
	+ end
	+ end
	+
	+ describe "api spec errors" do
	+ setup %{conn: conn} do
	+ app_token = insert(:oauth_token, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("authorization", "Bearer " <> app_token.token)
	+ \|> put_req_header("content-type", "multipart/form-data")
	+
	+ [conn: conn]
	+ end
	+
	+ setup do: clear_config([:instance, :registrations_open], true)
	+ setup do: clear_config([Pleroma.Captcha, :enabled], false)
	+
	+ test "returns errors when missed required field", %{conn: conn} do
	+ params = %{
	+ email: "lain@example.org",
	+ agreement: true
	+ }
	+
	+ assert %{
	+ "error" => "Please review the submission",
	+ "fields" => %{
	+ "password" => ["Missing field: password."],
	+ "username" => ["Missing field: username."]
	+ },
	+ "identifier" => "review_submission"
	+ } ==
	+ conn
	+ \|> post("/api/v1/accounts", params)
	+ \|> json_response_and_validate_schema(:bad_request)
	+ end
	+ end
	+end
	diff --git a/test/pleroma/web/twitter_api/twitter_api_test.exs b/test/pleroma/web/twitter_api/twitter_api_test.exs
	index 20a45cb6f..d433b507b 100644
	--- a/test/pleroma/web/twitter_api/twitter_api_test.exs
	+++ b/test/pleroma/web/twitter_api/twitter_api_test.exs
	@@ -1,432 +1,436 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.TwitterAPI.TwitterAPI

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

	test "it registers a new user and returns the user." do
	data = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:password => "bear",
	:confirm => "bear"
	}

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

	assert user == User.get_cached_by_nickname("lain")
	end

	test "it registers a new user with empty string in bio and returns the user" do
	data = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:bio => "",
	:password => "bear",
	:confirm => "bear"
	}

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

	assert user == User.get_cached_by_nickname("lain")
	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 = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:bio => "",
	:password => "bear",
	:confirm => "bear"
	}

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

	assert user.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 sends an admin email if :account_approval_required is specified in instance config" do
	admin = insert(:user, is_admin: true)
	setting = Pleroma.Config.get([:instance, :account_approval_required])

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

	data = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:bio => "",
	:password => "bear",
	:confirm => "bear",
	:reason => "I love anime"
	}

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

	assert user.approval_pending

	email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, 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: {admin.name, admin.email},
	html_body: email.html_body
	)
	end

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	:username => "john",
	:email => "john@gmail.com",
	:fullname => "John Doe",
	:bio => "test",
	:password => "bear",
	:confirm => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:bio => "@john test",
	:password => "bear",
	:confirm => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	~s(<span class="h-card"><a class="u-url mention" data-user="#{user1.id}" href="#{
	user1.ap_id
	}" rel="ugc">@<span>john</span></a></span> test)

	assert user2.bio == expected_text
	end

	describe "register with one time token" do
	setup do: clear_config([:instance, :registrations_open], false)

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

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

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

	assert user == User.get_cached_by_nickname("vinny")

	invite = Repo.get_by(UserInviteToken, token: invite.token)
	assert invite.used == true
	end

	test "returns error on invalid token" do
	data = %{
	:username => "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"
	+ assert msg == %{invite: ["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 = %{
	:username => "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"
	+ assert msg == %{invite: ["Expired token"]}
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with date limited token" do
	setup do: clear_config([:instance, :registrations_open], false)

	setup do
	data = %{
	:username => "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)

	assert user == User.get_cached_by_nickname("vinny")
	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"
	+ assert msg == %{invite: ["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: clear_config([:instance, :registrations_open], false)

	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 = %{
	:username => "vinny",
	:email => "pasta@pizza.vs",
	:fullname => "Vinny Vinesauce",
	:bio => "streamer",
	:password => "hiptofbees",
	:confirm => "hiptofbees",
	:token => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	assert user == User.get_cached_by_nickname("vinny")

	invite = Repo.get_by(UserInviteToken, token: invite.token)
	assert invite.used == true

	data = %{
	:username => "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"
	+ assert msg == %{invite: ["Expired token"]}
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with reusable date limited token" do
	setup do: clear_config([:instance, :registrations_open], false)

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

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

	{:ok, user} = TwitterAPI.register_user(data)
	assert user == User.get_cached_by_nickname("vinny")

	invite = Repo.get_by(UserInviteToken, token: invite.token)
	refute invite.used
	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 = %{
	:username => "vinny",
	:email => "pasta@pizza.vs",
	:fullname => "Vinny Vinesauce",
	:bio => "streamer",
	:password => "hiptofbees",
	:confirm => "hiptofbees",
	:token => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	assert user == User.get_cached_by_nickname("vinny")

	invite = Repo.get_by(UserInviteToken, token: invite.token)
	assert invite.used == true

	data = %{
	:username => "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"
	+ assert msg == %{invite: ["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 = %{
	:username => "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"
	+ assert msg == %{invite: ["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 = %{
	:username => "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"
	+ assert msg == %{invite: ["Expired token"]}
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	test "it returns the error on registration problems" do
	data = %{
	:username => "lain",
	:email => "lain@wired.jp",
	:fullname => "lain iwakura",
	:bio => "close the world."
	}

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

	- assert is_binary(error)
	+ assert error == %{
	+ password: ["can't be blank"],
	+ password_confirmation: ["can't be blank"]
	+ }
	+
	refute User.get_cached_by_nickname("lain")
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index fb82be0c4..b4f745413 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,445 +1,454 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo
	alias Pleroma.Object
	alias Pleroma.User

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

	def user_factory do
	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Pbkdf2.hash_pwd_salt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	discoverable: true,
	last_digest_emailed_at: NaiveDateTime.utc_now(),
	last_refreshed_at: NaiveDateTime.utc_now(),
	notification_settings: %Pleroma.User.NotificationSetting{},
	multi_factor_authentication_settings: %Pleroma.MFA.Settings{},
	ap_enabled: true
	}

	%{
	user
	\| ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	following_address: User.ap_following(user),
	raw_bio: user.bio
	}
	end

	def user_relationship_factory(attrs \\ %{}) do
	source = attrs[:source] \|\| insert(:user)
	target = attrs[:target] \|\| insert(:user)
	relationship_type = attrs[:relationship_type] \|\| :block

	%Pleroma.UserRelationship{
	source_id: source.id,
	target_id: target.id,
	relationship_type: relationship_type
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"source" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def audio_factory(attrs \\ %{}) do
	text = sequence(:text, &"lain radio episode #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Audio",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"artist" => "lain",
	"title" => text,
	"album" => "lain radio",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"actor" => user.ap_id,
	"length" => 180_000
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def listen_factory do
	audio = insert(:audio)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Listen",
	"actor" => audio.data["actor"],
	"to" => audio.data["to"],
	"object" => audio.data,
	"published" => audio.data["published"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def direct_note_factory do
	user2 = insert(:user)

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	note_factory()
	\|> Map.put("type", "Article")
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data["id"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => object.data["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Map.merge(attrs[:data_attrs] \|\| %{})

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def report_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	activity = attrs[:activity] \|\| insert(:note_activity)
	state = attrs[:state] \|\| "open"

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Flag",
	"object" => [activity.actor, activity.data["id"]],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"to" => [],
	"cc" => [activity.actor],
	"context" => activity.data["context"],
	"state" => state
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"] ++ data["cc"]
	}
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: sequence(:client_name, &"Some client #{&1}"),
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push", "admin"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory(attrs \\ %{}) do
	scopes = Map.get(attrs, :scopes, ["read"])
	oauth_app = Map.get_lazy(attrs, :app, fn -> insert(:oauth_app, scopes: scopes) end)
	user = Map.get_lazy(attrs, :user, fn -> build(:user) end)

	valid_until =
	Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10))

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	scopes: scopes,
	user: user,
	app: oauth_app,
	valid_until: valid_until
	}
	end

	def oauth_admin_token_factory(attrs \\ %{}) do
	user = Map.get_lazy(attrs, :user, fn -> build(:user, is_admin: true) end)

	scopes =
	attrs
	\|> Map.get(:scopes, ["admin"])
	\|> Kernel.++(["admin"])
	\|> Enum.uniq()

	attrs = Map.merge(attrs, %{user: user, scopes: scopes})
	oauth_token_factory(attrs)
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end

	def config_factory(attrs \\ %{}) do
	%Pleroma.ConfigDB{
	key: sequence(:key, &String.to_atom("some_key_#{&1}")),
	group: :pleroma,
	value:
	sequence(
	:value,
	&%{another_key: "#{&1}somevalue", another: "#{&1}somevalue"}
	)
	}
	\|> merge_attributes(attrs)
	end

	def marker_factory do
	%Pleroma.Marker{
	user: build(:user),
	timeline: "notifications",
	lock_version: 0,
	last_read_id: "1"
	}
	end

	def mfa_token_factory do
	%Pleroma.MFA.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	authorization: build(:oauth_authorization),
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user)
	}
	end

	def filter_factory do
	%Pleroma.Filter{
	user: build(:user),
	filter_id: sequence(:filter_id, & &1),
	phrase: "cofe"
	}
	end
	+
	+ def user_invite_token_factory do
	+ %Pleroma.UserInviteToken{
	+ token: Base.url_encode64(:crypto.strong_rand_bytes(32)),
	+ used: false,
	+ invite_type: "one_time",
	+ uses: 0
	+ }
	+ end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 2:27 AM (9 h, 43 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768666
Default Alt Text: (163 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions