No OneTemporary
Actions

Authored By

Unknown

Size

277 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/changelog.d/otp26.add b/changelog.d/otp26.add
	new file mode 100644
	index 000000000..b019afdf3
	--- /dev/null
	+++ b/changelog.d/otp26.add
	@@ -0,0 +1 @@
	+Support for Erlang OTP 26
	diff --git a/docs/installation/generic_dependencies.include b/docs/installation/generic_dependencies.include
	index 3365a36a8..aebf21e7c 100644
	--- a/docs/installation/generic_dependencies.include
	+++ b/docs/installation/generic_dependencies.include
	@@ -1,16 +1,16 @@
	## Required dependencies

	* PostgreSQL >=9.6
	* Elixir >=1.11.0 <1.15
	-* Erlang OTP >=22.2.0 <26
	+* Erlang OTP >=22.2.0 (supported: <27)
	* git
	* file / libmagic
	* gcc or clang
	* GNU make
	* CMake

	## Optional dependencies

	* ImageMagick
	* FFmpeg
	* exiftool
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 00268b121..8ba845364 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,1028 +1,1028 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router
	import Phoenix.LiveDashboard.Router

	pipeline :accepts_html do
	plug(:accepts, ["html"])
	end

	pipeline :accepts_html_xml do
	plug(:accepts, ["html", "xml", "rss", "atom"])
	end

	pipeline :accepts_html_json do
	plug(:accepts, ["html", "activity+json", "json"])
	end

	pipeline :accepts_html_xml_json do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	end

	pipeline :accepts_xml_rss_atom do
	plug(:accepts, ["xml", "rss", "atom"])
	end

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Web.Plugs.OAuthPlug)
	plug(Pleroma.Web.Plugs.UserEnabledPlug)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	end

	# Note: expects _user_ authentication (user-unbound app-bound tokens don't qualify)
	pipeline :expect_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectAuthenticatedCheckPlug)
	end

	# Note: expects public instance or _user_ authentication (user-unbound tokens don't qualify)
	pipeline :expect_public_instance_or_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

	pipeline :authenticate do
	plug(Pleroma.Web.Plugs.OAuthPlug)
	plug(Pleroma.Web.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Web.Plugs.UserFetcherPlug)
	plug(Pleroma.Web.Plugs.AuthenticationPlug)
	end

	pipeline :after_auth do
	plug(Pleroma.Web.Plugs.UserEnabledPlug)
	plug(Pleroma.Web.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	plug(Pleroma.Web.Plugs.UserTrackingPlug)
	end

	pipeline :base_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(:authenticate)
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :no_auth_or_privacy_expectations_api do
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	end

	# Pipeline for app-related endpoints (no user auth checks — app-bound tokens must be supported)
	pipeline :app_api do
	plug(:no_auth_or_privacy_expectations_api)
	end

	pipeline :api do
	plug(:expect_public_instance_or_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	end

	pipeline :authenticated_api do
	plug(:expect_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	end

	pipeline :admin_api do
	plug(:expect_user_authentication)
	plug(:base_api)
	plug(Pleroma.Web.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Web.Plugs.UserIsStaffPlug)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	end

	pipeline :require_admin do
	plug(Pleroma.Web.Plugs.UserIsAdminPlug)
	end

	pipeline :require_privileged_role_users_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_delete)
	end

	pipeline :require_privileged_role_users_manage_credentials do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_credentials)
	end

	pipeline :require_privileged_role_messages_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_read)
	end

	pipeline :require_privileged_role_users_manage_tags do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_tags)
	end

	pipeline :require_privileged_role_users_manage_activation_state do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_activation_state)
	end

	pipeline :require_privileged_role_users_manage_invites do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_invites)
	end

	pipeline :require_privileged_role_reports_manage_reports do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :reports_manage_reports)
	end

	pipeline :require_privileged_role_users_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_read)
	end

	pipeline :require_privileged_role_messages_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_delete)
	end

	pipeline :require_privileged_role_emoji_manage_emoji do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :emoji_manage_emoji)
	end

	pipeline :require_privileged_role_instances_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :instances_delete)
	end

	pipeline :require_privileged_role_moderation_log_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :moderation_log_read)
	end

	pipeline :require_privileged_role_statistics_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :statistics_read)
	end

	pipeline :require_privileged_role_announcements_manage_announcements do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :announcements_manage_announcements)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	end

	pipeline :well_known do
	- plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	+ plug(:accepts, ["json", "jrd", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	pipeline :static_fe do
	plug(Pleroma.Web.Plugs.StaticFEPlug)
	end

	scope "/api/v1/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	post("/remote_interaction", UtilController, :remote_interaction)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:pleroma_api)

	get("/federation_status", InstancesController, :show)
	end

	scope "/api/v1/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	# AdminAPI: only admins can perform these actions
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :require_admin])

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)

	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	post("/users/permission_group/:permission_group", AdminAPIController, :right_add_multiple)

	delete(
	"/users/permission_group/:permission_group",
	AdminAPIController,
	:right_delete_multiple
	)

	post("/users/follow", UserController, :follow)
	post("/users/unfollow", UserController, :unfollow)
	post("/users", UserController, :create)

	patch("/users/suggest", UserController, :suggest)
	patch("/users/unsuggest", UserController, :unsuggest)

	get("/relay", RelayController, :index)
	post("/relay", RelayController, :follow)
	delete("/relay", RelayController, :unfollow)

	get("/instance_document/:name", InstanceDocumentController, :show)
	patch("/instance_document/:name", InstanceDocumentController, :update)
	delete("/instance_document/:name", InstanceDocumentController, :delete)

	get("/config", ConfigController, :show)
	post("/config", ConfigController, :update)
	get("/config/descriptions", ConfigController, :descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/oauth_app", OAuthAppController, :index)
	post("/oauth_app", OAuthAppController, :create)
	patch("/oauth_app/:id", OAuthAppController, :update)
	delete("/oauth_app/:id", OAuthAppController, :delete)

	get("/media_proxy_caches", MediaProxyCacheController, :index)
	post("/media_proxy_caches/delete", MediaProxyCacheController, :delete)
	post("/media_proxy_caches/purge", MediaProxyCacheController, :purge)

	get("/frontends", FrontendController, :index)
	post("/frontends/install", FrontendController, :install)

	post("/backups", AdminAPIController, :create_backup)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_announcements_manage_announcements)

	get("/announcements", AnnouncementController, :index)
	post("/announcements", AnnouncementController, :create)
	get("/announcements/:id", AnnouncementController, :show)
	patch("/announcements/:id", AnnouncementController, :change)
	delete("/announcements/:id", AnnouncementController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_delete)

	delete("/users", UserController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_credentials)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)
	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_read)

	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)
	get("/users/:nickname/chats", AdminAPIController, :list_user_chats)

	get("/statuses", StatusController, :index)

	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)

	get("/instances/:instance/statuses", InstanceController, :list_statuses)

	get("/statuses/:id", StatusController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_tags)

	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_activation_state)

	patch("/users/:nickname/toggle_activation", UserController, :toggle_activation)
	patch("/users/activate", UserController, :activate)
	patch("/users/deactivate", UserController, :deactivate)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_invites)

	patch("/users/approve", UserController, :approve)
	post("/users/invite_token", InviteController, :create)
	get("/users/invites", InviteController, :index)
	post("/users/revoke_invite", InviteController, :revoke)
	post("/users/email_invite", InviteController, :email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_reports_manage_reports)

	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	patch("/reports", ReportController, :update)
	post("/reports/:id/notes", ReportController, :notes_create)
	delete("/reports/:report_id/notes/:id", ReportController, :notes_delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_read)

	get("/users", UserController, :index)
	get("/users/:nickname", UserController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_delete)

	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)

	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_instances_delete)

	delete("/instances/:instance", InstanceController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_moderation_log_read)

	get("/moderation_log", AdminAPIController, :list_log)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_statistics_read)

	get("/stats", AdminAPIController, :stats)
	end

	scope "/api/v1/pleroma/emoji", Pleroma.Web.PleromaAPI do
	scope "/pack" do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	post("/", EmojiPackController, :create)
	patch("/", EmojiPackController, :update)
	delete("/", EmojiPackController, :delete)
	end

	scope "/pack" do
	pipe_through(:api)

	get("/", EmojiPackController, :show)
	end

	# Modifying packs
	scope "/packs" do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	get("/import", EmojiPackController, :import_from_filesystem)
	get("/remote", EmojiPackController, :remote)
	post("/download", EmojiPackController, :download)

	post("/files", EmojiFileController, :create)
	patch("/files", EmojiFileController, :update)
	delete("/files", EmojiFileController, :delete)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)

	get("/", EmojiPackController, :index)
	get("/archive", EmojiPackController, :archive)
	end
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/main/ostatus", UtilController, :show_subscribe_form)
	get("/ostatus_subscribe", RemoteFollowController, :follow)
	post("/ostatus_subscribe", RemoteFollowController, :do_follow)

	get("/authorize_interaction", RemoteFollowController, :authorize_interaction)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	post("/change_email", UtilController, :change_email)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notification_settings)
	post("/disable_account", UtilController, :disable_account)
	post("/move_account", UtilController, :move_account)

	put("/aliases", UtilController, :add_alias)
	get("/aliases", UtilController, :list_aliases)
	delete("/aliases", UtilController, :delete_alias)
	end

	scope "/api/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)

	post("/mutes_import", UserImportController, :mutes)
	post("/blocks_import", UserImportController, :blocks)
	post("/follow_import", UserImportController, :follow)

	get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
	get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
	post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
	delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	# Note: use /api/v1/accounts/verify_credentials for userinfo of signed-in user

	get("/registration_details", OAuthController, :registration_details)

	post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
	get("/mfa", MFAController, :show)

	scope [] do
	pipe_through(:oauth)

	get("/authorize", OAuthController, :authorize)
	post("/authorize", OAuthController, :create_authorization)
	end

	scope [] do
	pipe_through(:fetch_session)

	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	post("/mfa/challenge", MFAController, :challenge)
	end

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)

	get("/apps", AppController, :index)
	get("/statuses/:id/reactions/:emoji", EmojiReactionController, :index)
	get("/statuses/:id/reactions", EmojiReactionController, :index)
	end

	scope "/api/v0/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)
	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)

	post("/chats/by-account-id/:id", ChatController, :create)
	get("/chats", ChatController, :index)
	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	post("/chats/:id/messages", ChatController, :post_chat_message)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	post("/chats/:id/read", ChatController, :mark_as_read)
	post("/chats/:id/messages/:message_id/read", ChatController, :mark_message_as_read)

	get("/conversations/:id/statuses", ConversationController, :statuses)
	get("/conversations/:id", ConversationController, :show)
	post("/conversations/read", ConversationController, :mark_as_read)
	patch("/conversations/:id", ConversationController, :update)

	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", NotificationController, :mark_as_read)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :create)

	get("/backups", BackupController, :index)
	post("/backups", BackupController, :create)
	end

	scope [] do
	pipe_through(:api)
	get("/accounts/:id/favourites", AccountController, :favourites)
	get("/accounts/:id/endorsements", AccountController, :endorsements)

	get("/statuses/:id/quotes", StatusController, :quotes)
	end

	scope [] do
	pipe_through(:authenticated_api)

	post("/accounts/:id/subscribe", AccountController, :subscribe)
	post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)

	get("/birthdays", AccountController, :birthdays)
	end

	scope [] do
	pipe_through(:authenticated_api)

	get("/settings/:app", SettingsController, :show)
	patch("/settings/:app", SettingsController, :update)
	end

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)
	get("/accounts/:id/scrobbles", ScrobbleController, :index)
	end

	scope "/api/v2/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)
	get("/chats", ChatController, :index2)
	end
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	get("/accounts/verify_credentials", AccountController, :verify_credentials)
	patch("/accounts/update_credentials", AccountController, :update_credentials)

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
	get("/endorsements", AccountController, :endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)
	post("/accounts/:id/note", AccountController, :note)
	post("/accounts/:id/pin", AccountController, :endorse)
	post("/accounts/:id/unpin", AccountController, :unendorse)
	post("/accounts/:id/remove_from_followers", AccountController, :remove_from_followers)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :mark_as_read)
	delete("/conversations/:id", ConversationController, :delete)

	get("/domain_blocks", DomainBlockController, :index)
	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)

	get("/filters", FilterController, :index)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	get("/follow_requests", FollowRequestController, :index)
	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)
	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	get("/markers", MarkerController, :index)
	post("/markers", MarkerController, :upsert)

	post("/media", MediaController, :create)
	get("/media/:id", MediaController, :show)
	put("/media/:id", MediaController, :update)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)

	post("/notifications/:id/dismiss", NotificationController, :dismiss)
	post("/notifications/clear", NotificationController, :clear)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
	# Deprecated: was removed in Mastodon v3, use `/notifications/:id/dismiss` instead
	post("/notifications/dismiss", NotificationController, :dismiss_via_body)

	post("/polls/:id/votes", PollController, :vote)

	post("/reports", ReportController, :create)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	# Unlike `GET /api/v1/accounts/:id/favourites`, demands authentication
	get("/favourites", StatusController, :favourites)
	get("/bookmarks", StatusController, :bookmarks)

	post("/statuses", StatusController, :create)
	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)
	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :show)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)

	get("/suggestions", SuggestionController, :index)
	delete("/suggestions/:account_id", SuggestionController, :dismiss)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)
	get("/timelines/list/:list_id", TimelineController, :list)

	get("/announcements", AnnouncementController, :index)
	post("/announcements/:id/dismiss", AnnouncementController, :mark_read)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:app_api)

	post("/apps", AppController, :create)
	get("/apps/verify_credentials", AppController, :verify_credentials)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	get("/accounts/search", SearchController, :account_search)
	get("/search", SearchController, :search)

	get("/accounts/lookup", AccountController, :lookup)

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	post("/accounts", AccountController, :create)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)
	get("/statuses/:id/history", StatusController, :show_history)
	get("/statuses/:id/source", StatusController, :show_source)

	get("/custom_emojis", CustomEmojiController, :index)

	get("/trends", MastodonAPIController, :empty_array)

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)

	get("/polls/:id", PollController, :show)

	get("/directory", DirectoryController, :index)
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	get("/search", SearchController, :search2)

	post("/media", MediaController, :create2)

	get("/suggestions", SuggestionController, :index2)

	get("/instance", InstanceController, :show2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)
	end

	scope "/api" do
	pipe_through(:base_api)

	get("/openapi", OpenApiSpex.Plug.RenderSpec, [])
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)
	end

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_json, :http_signature, :static_fe])

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)

	# Mastodon compatibility routes
	get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)
	end

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_xml_json, :http_signature, :static_fe])

	# Note: returns user _profile_ for json requests, redirects to user _feed_ for non-json ones
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through([:accepts_html_xml])

	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_html)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_xml_rss_atom)
	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:browser)
	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	# Server to Server (S2S) AP interactions
	pipeline :activitypub do
	plug(:ap_service_actor)
	plug(:http_signature)
	end

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)

	# The following two are S2S as well, see `ActivityPub.fetch_follow_information_for_user/1`:
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	get("/users/:nickname/collections/featured", ActivityPubController, :pinned)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web do
	pipe_through(:api)

	get("/manifest.json", ManifestController, :show)
	end

	scope "/", Pleroma.Web do
	pipe_through(:pleroma_html)

	post("/auth/password", TwitterAPI.PasswordController, :request)
	end

	scope "/proxy/", Pleroma.Web do
	get("/preview/:sig/:url", MediaProxy.MediaProxyController, :preview)
	get("/preview/:sig/:url/:filename", MediaProxy.MediaProxyController, :preview)
	get("/:sig/:url", MediaProxy.MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxy.MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	scope "/" do
	pipe_through([:pleroma_html, :authenticate, :require_admin])
	live_dashboard("/phoenix/live_dashboard")
	end

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

	scope "/test/api", Pleroma.Tests do
	pipe_through(:api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Pleroma.Web.Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	match(:, "/api/pleroma/path", LegacyPleromaApiRerouterPlug, [])
	get("/api/*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector_with_preload)

	options("/*path", RedirectController, :empty)
	end

	def get_api_routes do
	Phoenix.Router.routes(__MODULE__)
	\|> Enum.reject(fn r -> r.plug == Pleroma.Web.Fallback.RedirectController end)
	\|> Enum.map(fn r ->
	r.path
	\|> String.split("/", trim: true)
	\|> List.first()
	end)
	\|> Enum.uniq()
	end
	end
	diff --git a/lib/pleroma/web/web_finger/web_finger_controller.ex b/lib/pleroma/web/web_finger/web_finger_controller.ex
	index 9e5efb77f..021df9bc5 100644
	--- a/lib/pleroma/web/web_finger/web_finger_controller.ex
	+++ b/lib/pleroma/web/web_finger/web_finger_controller.ex
	@@ -1,45 +1,45 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFinger.WebFingerController do
	use Pleroma.Web, :controller

	alias Pleroma.Web.WebFinger

	plug(Pleroma.Web.Plugs.SetFormatPlug)
	plug(Pleroma.Web.Plugs.FederatingPlug)

	def host_meta(conn, _params) do
	xml = WebFinger.host_meta()

	conn
	\|> put_resp_content_type("application/xrd+xml")
	\|> send_resp(200, xml)
	end

	def webfinger(%{assigns: %{format: format}} = conn, %{"resource" => resource})
	when format in ["xml", "xrd+xml"] do
	with {:ok, response} <- WebFinger.webfinger(resource, "XML") do
	conn
	\|> put_resp_content_type("application/xrd+xml")
	\|> send_resp(200, response)
	else
	_e -> send_resp(conn, 404, "Couldn't find user")
	end
	end

	def webfinger(%{assigns: %{format: format}} = conn, %{"resource" => resource})
	- when format in ["json", "jrd+json"] do
	+ when format in ["jrd", "json", "jrd+json"] do
	with {:ok, response} <- WebFinger.webfinger(resource, "JSON") do
	json(conn, response)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json("Couldn't find user")
	end
	end

	def webfinger(conn, _params), do: send_resp(conn, 400, "Bad Request")
	end
	diff --git a/mix.exs b/mix.exs
	index b4b77b161..2e622d9da 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,348 +1,348 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.6.51"),
	elixir: "~> 1.11",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors()],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: :covertool, summary: true],
	# 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, []}]
	]
	]
	]
	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,
	:fast_sanitize,
	:os_mon,
	:ssl
	],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks", "priv/scrubbers"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors, do: System.get_env("CI") == "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.7.3"},
	{:phoenix_ecto, "~> 4.4"},
	{:ecto_sql, "~> 3.10"},
	{:ecto_enum, "~> 1.4"},
	{:postgrex, ">= 0.0.0"},
	{:phoenix_html, "~> 3.3"},
	{:phoenix_live_reload, "~> 1.3.3", only: :dev},
	{:phoenix_live_view, "~> 0.19.0"},
	{:phoenix_live_dashboard, "~> 0.8.0"},
	{:telemetry_metrics, "~> 0.6"},
	{:telemetry_poller, "~> 1.0"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.5"},
	# oban 2.14 requires Elixir 1.12+
	{:oban, "~> 2.13.4"},
	{:gettext, "~> 0.20"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{: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, "~> 2.0.0-rc.1", override: true},
	{:finch, "~> 0.15"},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.8.0"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.7.2"},
	# earmark 1.4.23 requires Elixir 1.12+
	{:earmark, "1.4.22"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3.1"},
	# swoosh 1.11.2+ requires Elixir 1.12+
	{:swoosh, "~> 1.10.0"},
	{:phoenix_swoosh, "~> 1.1"},
	{:gen_smtp, "~> 0.13"},
	{:ex_syslogger, "~> 1.4"},
	- {:floki, "~> 0.27"},
	+ {:floki, "~> 0.35"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.5.3"},
	- {:http_signatures, "~> 0.1.1"},
	+ {:http_signatures, "~> 0.1.2"},
	{:telemetry, "~> 1.0.0", override: true},
	{:poolboy, "~> 1.5"},
	{:prom_ex, "~> 1.9"},
	{:recon, "~> 2.5"},
	{:joken, "~> 2.0"},
	{:pot, "~> 1.0"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter, "~> 0.1.1"},
	{: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: "90f6ce7672f70f56708792a98d98bd05176c9176"},
	{:restarter, path: "./restarter"},
	{:majic, "~> 1.0"},
	{:open_api_spex, "~> 3.16"},
	{:ecto_psql_extras, "~> 0.6"},
	{:vix, "~> 0.26.0"},
	{:elixir_make, "~> 0.7.7", override: true},
	{:blurhash, "~> 0.1.0", hex: :rinpatch_blurhash},

	## dev & test
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.6", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	{:covertool, "~> 2.0", only: :test},
	{:hackney, "~> 1.18.0", override: true},
	{:mox, "~> 1.0", only: :test},
	{:websockex, "~> 0.4.3", only: :test},
	{:benchee, "~> 1.0", only: :benchmark}
	] ++ 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"],
	copyright: &add_copyright/1,
	"copyright.bump": &bump_copyright/1
	]
	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"]))
	dotgit_present? = File.exists?(".git")

	git_pre_release =
	if git_available? and dotgit_present? 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?,
	true <- dotgit_present?,
	{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

	defp add_copyright(_) do
	year = NaiveDateTime.utc_now().year
	template = ~s[\
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	] \|> String.replace("\n", "\\n")

	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$ -exec "
	grep = "grep -L '# Copyright © [0-9\-]* Pleroma' {} \\;"
	xargs = "xargs -n1 sed -i'' '1s;^;#{template};'"

	:os.cmd(String.to_charlist("#{find}#{grep} \| #{xargs}"))
	end

	defp bump_copyright(_) do
	year = NaiveDateTime.utc_now().year
	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$"

	xargs =
	"xargs sed -i'' 's;# Copyright © [0-9\-]* Pleroma.*$;# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>;'"

	:os.cmd(String.to_charlist("#{find} \| #{xargs}"))
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 81a05687b..e5e2c0baa 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,145 +1,145 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"base62": {:hex, :base62, "1.2.2", "85c6627eb609317b70f555294045895ffaaeb1758666ab9ef9ca38865b11e629", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "d41336bda8eaa5be197f1e4592400513ee60518e5b9f4dcf38f4b4dae6f377bb"},
	"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.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
	"benchee": {:hex, :benchee, "1.1.0", "f3a43817209a92a1fade36ef36b86e1052627fd8934a8b937ac9ab3a76c43062", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}], "hexpm", "7da57d545003165a012b587077f6ba90b89210fd88074ce3c60ce239eb5e6d93"},
	"blurhash": {:hex, :rinpatch_blurhash, "0.1.0", "01a888b0f5f1f382ab52e4396f01831cbe8486ea5828604c90f4dac533d39a4b", [:mix], [{:mogrify, "~> 0.8.0", [hex: :mogrify, repo: "hexpm", optional: true]}], "hexpm", "19911a5dcbb0acb9710169a72f702bce6cb048822b12de566ccd82b2cc42b907"},
	"bunt": {:hex, :bunt, "0.2.1", "e2d4792f7bc0ced7583ab54922808919518d0e57ee162901a16a1b6664ef3b14", [:mix], [], "hexpm", "a330bfb4245239787b15005e66ae6845c9cd524a288f0d141c148b02603777a5"},
	"cachex": {:hex, :cachex, "3.6.0", "14a1bfbeee060dd9bec25a5b6f4e4691e3670ebda28c8ba2884b12fe30b36bf8", [: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", "ebf24e373883bc8e0c8d894a63bbe102ae13d918f790121f5cfe6e485cc8e2e2"},
	"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", "90f6ce7672f70f56708792a98d98bd05176c9176", [ref: "90f6ce7672f70f56708792a98d98bd05176c9176"]},
	"castore": {:hex, :castore, "0.1.22", "4127549e411bedd012ca3a308dede574f43819fe9394254ca55ab4895abfa1a2", [:mix], [], "hexpm", "c17576df47eb5aa1ee40cc4134316a99f5cad3e215d5c77b8dd3cfef12a22cac"},
	"cc_precompiler": {:hex, :cc_precompiler, "0.1.9", "e8d3364f310da6ce6463c3dd20cf90ae7bbecbf6c5203b98bf9b48035592649b", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "9dcab3d0f3038621f1601f13539e7a9ee99843862e66ad62827b0c42b2f58a54"},
	"certifi": {:hex, :certifi, "2.9.0", "6f2a475689dd47f19fb74334859d460a2dc4e3252a3324bd2111b8f0429e7e21", [:rebar3], [], "hexpm", "266da46bdb06d6c6d35fde799bcb28d36d985d424ad7c08b5bb48f5b5cdd4641"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.3.3", "2c564dac95a35650e9b6acfe6d2952083d8a08e4a89b93a481acb552b325892e", [:mix], [], "hexpm", "3e38c9c2cb080828116597ca8807bb482618a315bfafd98c90bc22a821cc84df"},
	"concurrent_limiter": {:hex, :concurrent_limiter, "0.1.1", "43ae1dc23edda1ab03dd66febc739c4ff710d047bb4d735754909f9a474ae01c", [:mix], [{:telemetry, "~> 0.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "53968ff238c0fbb4d7ed76ddb1af0be6f3b2f77909f6796e249e737c505a16eb"},
	"connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
	"cors_plug": {:hex, :cors_plug, "2.0.3", "316f806d10316e6d10f09473f19052d20ba0a0ce2a1d910ddf57d663dac402ae", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ee4ae1418e6ce117fc42c2ba3e6cbdca4e95ecd2fe59a05ec6884ca16d469aea"},
	"covertool": {:hex, :covertool, "2.0.6", "4a291b4e3449025b0595d8f44c8d7635d4f48f033be2ce88d22a329f36f94a91", [:rebar3], [], "hexpm", "5db3fcd82180d8ea4ad857d4d1ab21a8d31b5aee0d60d2f6c0f9e25a411d1e21"},
	"cowboy": {:hex, :cowboy, "2.10.0", "ff9ffeff91dae4ae270dd975642997afe2a1179d94b1887863e43f681a203e26", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "3afdccb7183cc6f143cb14d3cf51fa00e53db9ec80cdcd525482f5e99bc41d6b"},
	"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
	"cowlib": {:hex, :cowlib, "2.12.1", "a9fa9a625f1d2025fe6b462cb865881329b5caff8f1854d1cbc9f9533f00e1e1", [:make, :rebar3], [], "hexpm", "163b73f6367a7341b33c794c4e88e7dbfe6498ac42dcd69ef44c5bc5507c8db0"},
	"credo": {:hex, :credo, "1.7.0", "6119bee47272e85995598ee04f2ebbed3e947678dee048d10b5feca139435f75", [:mix], [{:bunt, "~> 0.2.1", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2.8", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "6839fcf63d1f0d1c0f450abc8564a57c43d644077ab96f2934563e68b8a769d7"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	"db_connection": {:hex, :db_connection, "2.6.0", "77d835c472b5b67fc4f29556dee74bf511bbafecdcaf98c27d27fa5918152086", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c2f992d15725e721ec7fbc1189d4ecdb8afef76648c746a8e1cad35e3b8a35f3"},
	"decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"earmark": {:hex, :earmark, "1.4.22", "ea3e45c6359446dc308be0a64ce82a03260d973de7d0625a762e6d352ff57958", [:mix], [{:earmark_parser, "~> 1.4.23", [hex: :earmark_parser, repo: "hexpm", optional: false]}], "hexpm", "1caf5145665a42fd76d5317286b0c171861fb1c04f86ab103dde76868814fdfb"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.32", "fa739a0ecfa34493de19426681b23f6814573faee95dfd4b4aafe15a7b5b32c6", [:mix], [], "hexpm", "b8b0dd77d60373e77a3d7e8afa598f325e49e8663a51bcc2b88ef41838cca755"},
	"eblurhash": {:git, "https://github.com/zotonic/eblurhash.git", "bc37ceb426ef021ee9927fb249bb93f7059194ab", [ref: "bc37ceb426ef021ee9927fb249bb93f7059194ab"]},
	"ecto": {:hex, :ecto, "3.10.3", "eb2ae2eecd210b4eb8bece1217b297ad4ff824b4384c0e3fdd28aaf96edd6135", [: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 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "44bec74e2364d491d70f7e42cd0d690922659d329f6465e89feb8a34e8cd3433"},
	"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_psql_extras": {:hex, :ecto_psql_extras, "0.7.14", "7a20cfe913b0476542b43870e67386461258734896035e3f284039fd18bd4c4c", [:mix], [{:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "22f5f98592dd597db9416fcef00effae0787669fdcb6faf447e982b553798e98"},
	"ecto_sql": {:hex, :ecto_sql, "3.10.2", "6b98b46534b5c2f8b8b5f03f126e75e2a73c64f3c071149d32987a5378b0fdbd", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.10.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "68c018debca57cb9235e3889affdaec7a10616a4e3a80c99fa1d01fdafaa9007"},
	"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.7.7", "7128c60c2476019ed978210c245badf08b03dbec4f24d05790ef791da11aa17c", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}], "hexpm", "5bc19fff950fad52bbe5f211b12db9ec82c6b34a9647da0c2224b8b8464c7e6c"},
	"esbuild": {:hex, :esbuild, "0.5.0", "d5bb08ff049d7880ee3609ed5c4b864bd2f46445ea40b16b4acead724fb4c4a3", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "f183a0b332d963c4cfaf585477695ea59eef9a6f2204fdd0efa00e099694ffe5"},
	"eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
	"ex_aws": {:hex, :ex_aws, "2.1.9", "dc4865ecc20a05190a34a0ac5213e3e5e2b0a75a0c2835e923ae7bfeac5e3c31", [: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, "~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "3e6c776703c9076001fbe1f7c049535f042cb2afa0d2cbd3b47cbc4e92ac0d10"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.4.0", "ce8decb6b523381812798396bc0e3aaa62282e1b40520125d1f4eff4abdff0f4", [: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", "85dda6e27754d94582869d39cba3241d9ea60b6aa4167f9c88e309dc687e56bb"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.29.4", "6257ecbb20c7396b1fe5accd55b7b0d23f44b6aa18017b415cb4c2b91d997729", [:mix], [{:earmark_parser, "~> 1.4.31", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "2c6699a737ae46cb61e4ed012af931b57b699643b24dabe2400a8168414bc4f5"},
	"ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [: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", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
	"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"},
	"expo": {:hex, :expo, "0.4.1", "1c61d18a5df197dfda38861673d392e642649a9cef7694d2f97a587b2cfb319b", [:mix], [], "hexpm", "2ff7ba7a798c8c543c12550fa0e2cbc81b95d4974c65855d8d15ba7b37a1ce47"},
	"fast_html": {:hex, :fast_html, "2.0.5", "c61760340606c1077ff1f196f17834056cb1dd3d5cb92a9f2cabf28bc6221c3c", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "605f4f4829443c14127694ebabb681778712ceecb4470ec32aa31012330e6506"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.3", "67b93dfb34e302bef49fec3aaab74951e0f0602fd9fa99085987af05bd91c7a5", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "e8ad286d10d0386e15d67d0ee125245ebcfbc7d7290b08712ba9013c8c5e56e2"},
	"file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
	"finch": {:hex, :finch, "0.16.0", "40733f02c89f94a112518071c0a91fe86069560f5dbdb39f9150042f44dcfb1a", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.6 or ~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "f660174c4d519e5fec629016054d60edd822cdfe2b7270836739ac2f97735ec5"},
	"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.34.3", "5e2dcaec5d7c228ce5b1d3501502e308b2d79eb655e4191751a1fe491c37feac", [:mix], [], "hexpm", "9577440eea5b97924b4bf3c7ea55f7b8b6dce589f9b28b096cc294a8dc342341"},
	+ "floki": {:hex, :floki, "0.35.2", "87f8c75ed8654b9635b311774308b2760b47e9a579dabf2e4d5f1e1d42c39e0b", [:mix], [], "hexpm", "6b05289a8e9eac475f644f09c2e4ba7e19201fd002b89c28c1293e7bd16773d9"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gettext": {:hex, :gettext, "0.22.2", "6bfca374de34ecc913a28ba391ca184d88d77810a3e427afa8454a71a51341ac", [:mix], [{:expo, "~> 0.4.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "8a2d389673aea82d7eae387e6a2ccc12660610080ae7beb19452cfdc1ec30f60"},
	"gun": {:hex, :gun, "2.0.1", "160a9a5394800fcba41bc7e6d421295cf9a7894c2252c0678244948e3336ad73", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}], "hexpm", "a10bc8d6096b9502205022334f719cc9a08d9adcfbfc0dbee9ef31b56274a20b"},
	"hackney": {:hex, :hackney, "1.18.1", "f48bf88f521f2a229fc7bae88cf4f85adc9cd9bcf23b5dc8eb6a1788c662c4f6", [:rebar3], [{:certifi, "~>2.9.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~>6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~>1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.3.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~>1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "a4ecdaff44297e9b5894ae499e9a070ea1888c84afdd1fd9b7b2bc384950128e"},
	"hpax": {:hex, :hpax, "0.1.2", "09a75600d9d8bbd064cdd741f21fc06fc1f4cf3d0fcc335e5aa19be1a7235c84", [:mix], [], "hexpm", "2c87843d5a23f5f16748ebe77969880e29809580efdaccd615cd3bed628a8c13"},
	"html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
	- "http_signatures": {:hex, :http_signatures, "0.1.1", "ca7ebc1b61542b163644c8c3b1f0e0f41037d35f2395940d3c6c7deceab41fd8", [:mix], [], "hexpm", "cc3b8a007322cc7b624c0c15eec49ee58ac977254ff529a3c482f681465942a3"},
	+ "http_signatures": {:hex, :http_signatures, "0.1.2", "ed1cc7043abcf5bb4f30d68fb7bad9d618ec1a45c4ff6c023664e78b67d9c406", [:mix], [], "hexpm", "f08aa9ac121829dae109d608d83c84b940ef2f183ae50f2dd1e9a8bc619d8be7"},
	"httpoison": {:hex, :httpoison, "1.8.2", "9eb9c63ae289296a544842ef816a85d881d4a31f518a0fec089aaa744beae290", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "2bb350d26972e30c96e2ca74a1aaf8293d61d0742ff17f01e0279fef11599921"},
	"idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
	"inet_cidr": {:hex, :inet_cidr, "1.0.4", "a05744ab7c221ca8e395c926c3919a821eb512e8f36547c062f62c4ca0cf3d6e", [:mix], [], "hexpm", "64a2d30189704ae41ca7dbdd587f5291db5d1dda1414e0774c29ffc81088c1bc"},
	"jason": {:hex, :jason, "1.4.1", "af1504e35f629ddcdd6addb3513c3853991f694921b1b9368b0bd32beb9f1b63", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fbb01ecdfd565b56261302f7e1fcc27c4fb8f32d56eab74db621fc154604a7a1"},
	"joken": {:hex, :joken, "2.6.0", "b9dd9b6d52e3e6fcb6c65e151ad38bf4bc286382b5b6f97079c47ade6b1bcc6a", [:mix], [{:jose, "~> 1.11.5", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "5a95b05a71cd0b54abd35378aeb1d487a23a52c324fa7efdffc512b655b5aaa7"},
	"jose": {:hex, :jose, "1.11.5", "3bc2d75ffa5e2c941ca93e5696b54978323191988eb8d225c2e663ddfefd515e", [:mix, :rebar3], [], "hexpm", "dcd3b215bafe02ea7c5b23dafd3eb8062a5cd8f2d904fd9caa323d37034ab384"},
	"jumper": {:hex, :jumper, "1.0.1", "3c00542ef1a83532b72269fab9f0f0c82bf23a35e27d278bfd9ed0865cecabff", [:mix], [], "hexpm", "318c59078ac220e966d27af3646026db9b5a5e6703cb2aa3e26bcfaba65b7433"},
	"linkify": {:hex, :linkify, "0.5.3", "5f8143d8f61f5ff08d3aeeff47ef6509492b4948d8f08007fbf66e4d2246a7f2", [:mix], [], "hexpm", "3ef35a1377d47c25506e07c1c005ea9d38d700699d92ee92825f024434258177"},
	"majic": {:hex, :majic, "1.0.0", "37e50648db5f5c2ff0c9fb46454d034d11596c03683807b9fb3850676ffdaab3", [:make, :mix], [{:elixir_make, "~> 0.6.1", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "7905858f76650d49695f14ea55cd9aaaee0c6654fa391671d4cf305c275a0a9e"},
	"makeup": {:hex, :makeup, "1.0.5", "d5a830bc42c9800ce07dd97fa94669dfb93d3bf5fcf6ea7a0c67b2e0e4a7f26c", [:mix], [{:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "cfa158c02d3f5c0c665d0af11512fed3fba0144cf1aadee0f2ce17747fba2ca9"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"makeup_erlang": {:hex, :makeup_erlang, "0.1.2", "ad87296a092a46e03b7e9b0be7631ddcf64c790fa68a9ef5323b6cbb36affc72", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f3f5a1ca93ce6e092d92b6d9c049bcda58a3b617a8d888f8e7231c85630e8108"},
	"meck": {:hex, :meck, "0.9.2", "85ccbab053f1db86c7ca240e9fc718170ee5bda03810a6292b5306bf31bae5f5", [:rebar3], [], "hexpm", "81344f561357dc40a8344afa53767c32669153355b626ea9fcbc8da6b3045826"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
	"mime": {:hex, :mime, "1.6.0", "dabde576a497cef4bbdd60aceee8160e02a6c89250d6c0b29e56c0dfb00db3d2", [:mix], [], "hexpm", "31a1a8613f8321143dde1dafc36006a17d28d02bdfecb9e95a880fa7aabd19a7"},
	"mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
	"mint": {:hex, :mint, "1.5.1", "8db5239e56738552d85af398798c80648db0e90f343c8469f6c6d8898944fb6f", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "4a63e1e76a7c3956abd2c72f370a0d0aecddc3976dea5c27eccbecfa5e7d5b1e"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.8", "7046a306b71db2488ef54395eeb74df0a7f335a7caca4a3d3875d1fc81c884dd", [:mix], [{:meck, "~> 0.9.2", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "7fa82364c97617d79bb7d15571193fc0c4fe5afd0c932cef09426b3ee6fe2022"},
	"mogrify": {:hex, :mogrify, "0.8.0", "3506f3ca3f7b95a155f3b4ef803b5db176f5a0633723e3fe85e0d6399e3b11c8", [:mix], [], "hexpm", "2278d245f07056ea3b586e98801e933695147066fa4cf563f552c1b4f0ff8ad9"},
	"mox": {:hex, :mox, "1.0.2", "dc2057289ac478b35760ba74165b4b3f402f68803dd5aecd3bfd19c183815d64", [:mix], [], "hexpm", "f9864921b3aaf763c8741b5b8e6f908f44566f1e427b2630e89e9a73b981fef2"},
	"nimble_options": {:hex, :nimble_options, "1.0.2", "92098a74df0072ff37d0c12ace58574d26880e522c22801437151a159392270e", [:mix], [], "hexpm", "fd12a8db2021036ce12a309f26f564ec367373265b53e25403f0ee697380f1b8"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.2.6", "91f2f4c357da4c4a0a548286c84a3a28004f68f05609b4534526871a22053cde", [:mix], [], "hexpm", "1c715055095d3f2705c4e236c18b618420a35490da94149ff8b580a2144f653f"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	"oban": {:hex, :oban, "2.13.6", "a0cb1bce3bd393770512231fb5a3695fa19fd3af10d7575bf73f837aee7abf43", [:mix], [{:ecto_sql, "~> 3.6", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3c1c5eb16f377b3cbbf2ea14be24d20e3d91285af9d1ac86260b7c2af5464887"},
	"octo_fetch": {:hex, :octo_fetch, "0.3.0", "89ff501d2ac0448556ff1931634a538fe6d6cd358ba827ce1747e6a42a46efbf", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "c07e44f2214ab153743b7b3182f380798d0b294b1f283811c1e30cff64096d3d"},
	"open_api_spex": {:hex, :open_api_spex, "3.17.3", "ada8e352eb786050dd639db2439d3316e92f3798eb2abd051f55bb9af825b37e", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "165db21a85ca83cffc8e7c8890f35b354eddda8255de7404a2848ed652b9f0fe"},
	"parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
	"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.7.10", "02189140a61b2ce85bb633a9b6fd02dff705a5f1596869547aeb2b2b95edd729", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "cf784932e010fd736d656d7fead6a584a4498efefe5b8227e9f383bf15bb79d0"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.4.2", "b21bd01fdeffcfe2fab49e4942aa938b6d3e89e93a480d4aee58085560a0bc0d", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "70242edd4601d50b69273b057ecf7b684644c19ee750989fd555625ae4ce8f5d"},
	"phoenix_html": {:hex, :phoenix_html, "3.3.3", "380b8fb45912b5638d2f1d925a3771b4516b9a78587249cabe394e0a5d579dc9", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "923ebe6fec6e2e3b3e569dfbdc6560de932cd54b000ada0208b5f45024bdd76c"},
	"phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.3", "7ff51c9b6609470f681fbea20578dede0e548302b0c8bdf338b5a753a4f045bf", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "f9470a0a8bae4f56430a23d42f977b5a6205fdba6559d76f932b876bfaec652d"},
	"phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
	"phoenix_live_view": {:hex, :phoenix_live_view, "0.19.5", "6e730595e8e9b8c5da230a814e557768828fd8dfeeb90377d2d8dbb52d4ec00a", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b2eaa0dd3cfb9bd7fb949b88217df9f25aed915e986a28ad5c8a0d054e7ca9d3"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "1.2.0", "a544d83fde4a767efb78f45404a74c9e37b2a9c5ea3339692e65a6966731f935", [:mix], [{:finch, "~> 0.8", [hex: :finch, repo: "hexpm", optional: true]}, {:hackney, "~> 1.10", [hex: :hackney, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.5", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "e88d117251e89a16b92222415a6d87b99a96747ddf674fc5c7631de734811dba"},
	"phoenix_template": {:hex, :phoenix_template, "1.0.3", "32de561eefcefa951aead30a1f94f1b5f0379bc9e340bb5c667f65f1edfa4326", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "16f4b6588a4152f3cc057b9d0c0ba7e82ee23afa65543da535313ad8d25d8e2c"},
	"phoenix_view": {:hex, :phoenix_view, "2.0.3", "4d32c4817fce933693741deeb99ef1392619f942633dde834a5163124813aad3", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "cd34049af41be2c627df99cd4eaa71fc52a328c0c3d8e7d4aa28f880c30e7f64"},
	"plug": {:hex, :plug, "1.15.1", "b7efd81c1a1286f13efb3f769de343236bd8b7d23b4a9f40d3002fc39ad8f74c", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "459497bd94d041d98d948054ec6c0b76feacd28eec38b219ca04c0de13c79d30"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.6.1", "9a3bbfceeb65eff5f39dab529e5cd79137ac36e913c02067dba3963a26efe9b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "de36e1a21f451a18b790f37765db198075c25875c64834bcc82d90b309eb6613"},
	"plug_crypto": {:hex, :plug_crypto, "2.0.0", "77515cc10af06645abbfb5e6ad7a3e9714f805ae118fa1a70205f80d2d70fe73", [:mix], [], "hexpm", "53695bae57cc4e54566d993eb01074e4d894b65a3766f1c43e2c61a1b0f45ea9"},
	"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.17.3", "c92cda8de2033a7585dae8c61b1d420a1a1322421df84da9a82a6764580c503d", [:mix], [{: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]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "946cf46935a4fdca7a81448be76ba3503cff082df42c6ec1ff16a4bdfbfb098d"},
	"pot": {:hex, :pot, "1.0.2", "13abb849139fdc04ab8154986abbcb63bdee5de6ed2ba7e1713527e33df923dd", [:rebar3], [], "hexpm", "78fe127f5a4f5f919d6ea5a2a671827bd53eb9d37e5b4128c0ad3df99856c2e0"},
	"prom_ex": {:hex, :prom_ex, "1.9.0", "63e6dda6c05cdeec1f26c48443dcc38ffd2118b3665ae8d2bd0e5b79f2aea03e", [:mix], [{:absinthe, ">= 1.6.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.0.2", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.5.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.15", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.4.0", [hex: :oban, repo: "hexpm", optional: true]}, {:octo_fetch, "~> 0.3", [hex: :octo_fetch, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.5.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.14.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.12.1", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, "~> 2.5", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:telemetry, ">= 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.0", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.0", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "01f3d4f69ec93068219e686cc65e58a29c42bea5429a8ff4e2121f19db178ee6"},
	"prometheus": {:hex, :prometheus, "4.10.0", "792adbf0130ff61b5fa8826f013772af24b6e57b984445c8d602c8a0355704a1", [:mix, :rebar3], [{:quantile_estimator, "~> 0.2.1", [hex: :quantile_estimator, repo: "hexpm", optional: false]}], "hexpm", "2a99bb6dce85e238c7236fde6b0064f9834dc420ddbd962aac4ea2a3c3d59384"},
	"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://github.com/lanodan/prometheus.ex.git", "31f7fbe4b71b79ba27efc2a5085746c4011ceb8f", [branch: "fix/elixir-1.14"]},
	"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"},
	"quantile_estimator": {:hex, :quantile_estimator, "0.2.1", "ef50a361f11b5f26b5f16d0696e46a9e4661756492c981f7b2229ef42ff1cd15", [:rebar3], [], "hexpm", "282a8a323ca2a845c9e6f787d166348f776c1d4a41ede63046d72d422e3da946"},
	"ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
	"recon": {:hex, :recon, "2.5.3", "739107b9050ea683c30e96de050bc59248fd27ec147696f79a8797ff9fa17153", [:mix, :rebar3], [], "hexpm", "6c6683f46fd4a1dfd98404b9f78dcabc7fcd8826613a89dcb984727a8c3099d7"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	"rustler": {:hex, :rustler, "0.30.0", "cefc49922132b072853fa9b0ca4dc2ffcb452f68fb73b779042b02d545e097fb", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "9ef1abb6a7dda35c47cfc649e6a5a61663af6cf842a55814a554a84607dee389"},
	"sleeplocks": {:hex, :sleeplocks, "1.1.2", "d45aa1c5513da48c888715e3381211c859af34bee9b8290490e10c90bb6ff0ca", [:rebar3], [], "hexpm", "9fe5d048c5b781d6305c1a3a0f40bb3dfc06f49bf40571f3d2d0c57eaa7f59a5"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
	"statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
	"sweet_xml": {:hex, :sweet_xml, "0.7.3", "debb256781c75ff6a8c5cbf7981146312b66f044a2898f453709a53e5031b45b", [:mix], [], "hexpm", "e110c867a1b3fe74bfc7dd9893aa851f0eed5518d0d7cad76d7baafd30e4f5ba"},
	"swoosh": {:hex, :swoosh, "1.10.3", "32f1531ee3fe4e82da8175c597bf3692938f8152eb981e0cbf57107b6c5924c1", [:mix], [{:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, 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 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8b7167d93047bac6e1a1c367bf7d899cf2e4fea0592ee04a70673548ef6091b9"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"table_rex": {:hex, :table_rex, "3.1.1", "0c67164d1714b5e806d5067c1e96ff098ba7ae79413cc075973e17c38a587caa", [:mix], [], "hexpm", "678a23aba4d670419c23c17790f9dcd635a4a89022040df7d5d772cb21012490"},
	"telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
	"telemetry_metrics": {:hex, :telemetry_metrics, "0.6.1", "315d9163a1d4660aedc3fee73f33f1d355dcc76c5c3ab3d59e76e3edf80eef1f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7be9e0871c41732c233be71e4be11b96e56177bf15dde64a8ac9ce72ac9834c6"},
	"telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.1.0", "4e15f6d7dbedb3a4e3aed2262b7e1407f166fcb9c30ca3f96635dfbbef99965c", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "0dd10e7fe8070095df063798f82709b0a1224c31b8baf6278b423898d591a069"},
	"telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
	"tesla": {:hex, :tesla, "1.4.4", "bb89aa0c9745190930366f6a2ac612cdf2d0e4d7fff449861baa7875afd797b2", [: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 or ~> 2.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 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "d5503a49f9dec1b287567ea8712d085947e247cb11b06bc54adb05bfde466457"},
	"timex": {:hex, :timex, "3.7.7", "3ed093cae596a410759104d878ad7b38e78b7c2151c6190340835515d4a46b8a", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "0ec4b09f25fe311321f9fc04144a7e3affe48eb29481d7a5583849b6c4dfa0a7"},
	"toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
	"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.5", "69f1ee029a49afa04ad77801febaf69385f3d3e3d1e4b56b9469025677b89a28", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "55519aa2a99e5d2095c1e61cc74c9be69688f8ab75c27da724eb8279ff402a5a"},
	"ueberauth": {:hex, :ueberauth, "0.10.5", "806adb703df87e55b5615cf365e809f84c20c68aa8c08ff8a416a5a6644c4b02", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3efd1f31d490a125c7ed453b926f7c31d78b97b8a854c755f5c40064bf3ac9e1"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm", "6c7729a2d214806450d29766abc2afaa7a2cbecf415be64f36a6691afebb50e5"},
	"vix": {:hex, :vix, "0.26.0", "027f10b6969b759318be84bd0bd8c88af877445e4e41cf96a0460392cea5399c", [:make, :mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:cc_precompiler, "~> 0.1.4 or ~> 0.2", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.7.3 or ~> 0.8", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}], "hexpm", "71b0a79ae7f199cacfc8e679b0e4ba25ee47dc02e182c5b9097efb29fbe14efd"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.1", "76d0e7375142dfee67391e7690e89f92578889cbcf2879377900b5620ee4708d", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.11.1", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "4f82b2e57622fb9337559058e8797cb0df7e7c9790793bdc4e40bc895f70e2a2"},
	"websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
	"websock_adapter": {:hex, :websock_adapter, "0.5.5", "9dfeee8269b27e958a65b3e235b7e447769f66b5b5925385f5a569269164a210", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "4b977ba4a01918acbf77045ff88de7f6972c2a009213c515a445c48f224ffce9"},
	"websockex": {:hex, :websockex, "0.4.3", "92b7905769c79c6480c02daacaca2ddd49de936d912976a4d3c923723b647bf0", [:mix], [], "hexpm", "95f2e7072b85a3a4cc385602d42115b73ce0b74a9121d0d6dbbf557645ac53e4"},
	}
	diff --git a/test/mix/tasks/pleroma/config_test.exs b/test/mix/tasks/pleroma/config_test.exs
	index cec1a79e4..7b2134129 100644
	--- a/test/mix/tasks/pleroma/config_test.exs
	+++ b/test/mix/tasks/pleroma/config_test.exs
	@@ -1,334 +1,334 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.ConfigTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Mix.Tasks.Pleroma.Config, as: MixTask
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	Application.delete_env(:pleroma, :first_setting)
	Application.delete_env(:pleroma, :second_setting)
	end)

	:ok
	end

	defp config_records do
	ConfigDB
	\|> Repo.all()
	\|> Enum.sort()
	end

	defp insert_config_record(group, key, value) do
	insert(:config,
	group: group,
	key: key,
	value: value
	)
	end

	test "error if file with custom settings doesn't exist" do
	MixTask.migrate_to_db("config/non_existent_config_file.exs")

	msg =
	"To migrate settings, you must define custom settings in config/non_existent_config_file.exs."

	assert_receive {:mix_shell, :info, [^msg]}, 15
	end

	describe "migrate_to_db/1" do
	setup do
	clear_config(:configurable_from_database, true)
	end

	@tag capture_log: true
	test "config migration refused when deprecated settings are found" do
	clear_config([:media_proxy, :whitelist], ["domain_without_scheme.com"])
	assert config_records() == []

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	assert_received {:mix_shell, :error, [message]}

	assert message =~
	"Migration is not allowed until all deprecation warnings have been resolved."
	end

	test "filtered settings are migrated to db" do
	assert config_records() == []

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config1 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	config2 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":second_setting"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: "Pleroma.Repo"})
	refute ConfigDB.get_by_params(%{group: ":postgrex", key: ":json_library"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: ":database"})

	assert config1.value == [key: "value", key2: [Repo]]
	assert config2.value == [key: "value2", key2: ["Activity"]]
	end

	test "config table is truncated before migration" do
	insert_config_record(:pleroma, :first_setting, key: "value", key2: ["Activity"])
	assert length(config_records()) == 1

	MixTask.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	assert config.value == [key: "value", key2: [Repo]]
	end
	end

	describe "with deletion of temp file" do
	setup do
	clear_config(:configurable_from_database, true)
	temp_file = "config/temp.exported_from_db.secret.exs"

	on_exit(fn ->
	:ok = File.rm(temp_file)
	end)

	{:ok, temp_file: temp_file}
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	insert_config_record(:pleroma, :setting_first, key: "value", key2: ["Activity"])
	insert_config_record(:pleroma, :setting_second, key: "value2", key2: [Repo])

	MixTask.run(["migrate_from_db", "--env", "temp", "-d"])

	assert config_records() == []

	file = File.read!(temp_file)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end

	test "load a settings with large values and pass to file", %{temp_file: temp_file} do
	insert(:config,
	key: :instance,
	value: [
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	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,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: ["text/plain", "text/html", "text/markdown", "text/bbcode"],
	autofollowed_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,
	external_user_synchronization: true,
	extended_nickname_format: true,
	multi_factor_authentication: [
	totp: [
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]
	]
	)

	MixTask.run(["migrate_from_db", "--env", "temp", "-d"])

	assert config_records() == []
	assert File.exists?(temp_file)
	{:ok, file} = File.read(temp_file)

	- assert file ==
	- "import Config\n\nconfig :pleroma, :instance,\n name: \"Pleroma\",\n email: \"example@example.com\",\n notify_email: \"noreply@example.com\",\n description: \"A Pleroma instance, an alternative fediverse server\",\n limit: 5000,\n chat_limit: 5000,\n remote_limit: 100_000,\n upload_limit: 16_000_000,\n avatar_upload_limit: 2_000_000,\n background_upload_limit: 4_000_000,\n banner_upload_limit: 4_000_000,\n poll_limits: %{\n max_expiration: 31_536_000,\n max_option_chars: 200,\n max_options: 20,\n min_expiration: 0\n },\n registrations_open: true,\n federating: true,\n federation_incoming_replies_max_depth: 100,\n federation_reachability_timeout_days: 7,\n allow_relay: true,\n public: true,\n quarantined_instances: [],\n managed_config: true,\n static_dir: \"instance/static/\",\n allowed_post_formats: [\"text/plain\", \"text/html\", \"text/markdown\", \"text/bbcode\"],\n autofollowed_nicknames: [],\n max_pinned_statuses: 1,\n attachment_links: false,\n max_report_comment_size: 1000,\n safe_dm_mentions: false,\n healthcheck: false,\n remote_post_retention_days: 90,\n skip_thread_containment: true,\n limit_to_local_content: :unauthenticated,\n user_bio_length: 5000,\n user_name_length: 100,\n max_account_fields: 10,\n max_remote_account_fields: 20,\n account_field_name_length: 512,\n account_field_value_length: 2048,\n external_user_synchronization: true,\n extended_nickname_format: true,\n multi_factor_authentication: [\n totp: [digits: 6, period: 30],\n backup_codes: [number: 2, length: 6]\n ]\n"
	+ assert file =~ "import Config\n"
	+ assert file =~ "A Pleroma instance, an alternative fediverse server"
	end
	end

	describe "migrate_from_db/1" do
	setup do: clear_config(:configurable_from_database, true)

	setup do
	insert_config_record(:pleroma, :setting_first, key: "value", key2: ["Activity"])
	insert_config_record(:pleroma, :setting_second, key: "value2", key2: [Repo])

	path = "test/instance_static"
	file_path = Path.join(path, "temp.exported_from_db.secret.exs")

	on_exit(fn -> File.rm!(file_path) end)

	[file_path: file_path]
	end

	test "with path parameter", %{file_path: file_path} do
	MixTask.run(["migrate_from_db", "--env", "temp", "--path", Path.dirname(file_path)])

	file = File.read!(file_path)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end

	test "release", %{file_path: file_path} do
	clear_config(:release, true)
	clear_config(:config_path, file_path)

	MixTask.run(["migrate_from_db", "--env", "temp"])

	file = File.read!(file_path)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	end
	end

	describe "operations on database config" do
	setup do: clear_config(:configurable_from_database, true)

	test "dumping a specific group" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")

	insert_config_record(:web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BOsPL-_KjNnjj_RMvLeR3dTOrcndi4TbMR0cu56gLGfGaT5m1gXxSfRHOcC4Dd78ycQL1gdhtx13qgKHmTM5xAI",
	private_key: "Ism6FNdS31nLCA94EfVbJbDdJXCxAZ8cZiB1JQPN_t4"
	)

	MixTask.run(["dump", "pleroma"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	refute_receive {
	:mix_shell,
	:info,
	[
	"config :web_push_encryption, :vapid_details, [subject: \"mailto:administrator@example.com\", public_key: \"BOsPL-_KjNnjj_RMvLeR3dTOrcndi4TbMR0cu56gLGfGaT5m1gXxSfRHOcC4Dd78ycQL1gdhtx13qgKHmTM5xAI\", private_key: \"Ism6FNdS31nLCA94EfVbJbDdJXCxAZ8cZiB1JQPN_t4\"]\r\n\r\n"
	]
	}

	# Ensure operations work when using atom syntax
	MixTask.run(["dump", ":pleroma"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}
	end

	test "dumping a specific key in a group" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)

	MixTask.run(["dump", "pleroma", "Pleroma.Captcha"])

	refute_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	assert_receive {:mix_shell, :info,
	["config :pleroma, Pleroma.Captcha, [enabled: false]\r\n\r\n"]}
	end

	test "dumps all configuration successfully" do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)

	MixTask.run(["dump"])

	assert_receive {:mix_shell, :info,
	["config :pleroma, :instance, [name: \"Pleroma Test\"]\r\n\r\n"]}

	assert_receive {:mix_shell, :info,
	["config :pleroma, Pleroma.Captcha, [enabled: false]\r\n\r\n"]}
	end
	end

	describe "when configdb disabled" do
	test "refuses to dump" do
	clear_config(:configurable_from_database, false)

	insert_config_record(:pleroma, :instance, name: "Pleroma Test")

	MixTask.run(["dump"])

	msg =
	"ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."

	assert_receive {:mix_shell, :error, [^msg]}
	end
	end

	describe "destructive operations" do
	setup do: clear_config(:configurable_from_database, true)

	setup do
	insert_config_record(:pleroma, :instance, name: "Pleroma Test")
	insert_config_record(:pleroma, Pleroma.Captcha, enabled: false)
	insert_config_record(:pleroma2, :key2, z: 1)

	assert length(config_records()) == 3

	:ok
	end

	test "deletes group of settings" do
	MixTask.run(["delete", "--force", "pleroma"])

	assert [%ConfigDB{group: :pleroma2, key: :key2}] = config_records()
	end

	test "deletes specified key" do
	MixTask.run(["delete", "--force", "pleroma", "Pleroma.Captcha"])

	assert [
	%ConfigDB{group: :pleroma, key: :instance},
	%ConfigDB{group: :pleroma2, key: :key2}
	] = config_records()
	end

	test "resets entire config" do
	MixTask.run(["reset", "--force"])

	assert config_records() == []
	end
	end
	end
	diff --git a/test/pleroma/activity_test.exs b/test/pleroma/activity_test.exs
	index e38384c9c..67943d879 100644
	--- a/test/pleroma/activity_test.exs
	+++ b/test/pleroma/activity_test.exs
	@@ -1,355 +1,356 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ActivityTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.ThreadMute
	import Pleroma.Factory

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

	test "returns an activity by it's AP id" do
	activity = insert(:note_activity)
	found_activity = Activity.get_by_ap_id(activity.data["id"])

	assert activity == found_activity
	end

	test "returns activities by it's objects AP ids" do
	activity = insert(:note_activity)
	object_data = Object.normalize(activity, fetch: false).data

	[found_activity] = Activity.get_all_create_by_object_ap_id(object_data["id"])

	assert activity == found_activity
	end

	test "returns the activity that created an object" do
	activity = insert(:note_activity)
	object_data = Object.normalize(activity, fetch: false).data

	found_activity = Activity.get_create_by_object_ap_id(object_data["id"])

	assert activity == found_activity
	end

	test "preloading a bookmark" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	activity = insert(:note_activity)
	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)
	{:ok, _bookmark2} = Bookmark.create(user2.id, activity.id)
	{:ok, bookmark3} = Bookmark.create(user3.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user3)
	\|> Repo.one()

	assert queried_activity.bookmark == bookmark3
	end

	test "setting thread_muted?" do
	activity = insert(:note_activity)
	user = insert(:user)
	annoyed_user = insert(:user)
	{:ok, _} = ThreadMute.add_mute(annoyed_user.id, activity.data["context"])

	activity_with_unset_thread_muted_field =
	Ecto.Query.from(Activity)
	\|> Repo.one()

	activity_for_user =
	Ecto.Query.from(Activity)
	\|> Activity.with_set_thread_muted_field(user)
	\|> Repo.one()

	activity_for_annoyed_user =
	Ecto.Query.from(Activity)
	\|> Activity.with_set_thread_muted_field(annoyed_user)
	\|> Repo.one()

	assert activity_with_unset_thread_muted_field.thread_muted? == nil
	assert activity_for_user.thread_muted? == false
	assert activity_for_annoyed_user.thread_muted? == true
	end

	describe "getting a bookmark" do
	test "when association is loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end

	test "when association is not loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end
	end

	describe "search" do
	setup do
	user = insert(:user)

	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/activities/1",
	"object" => %{
	"type" => "Note",
	"content" => "find me!",
	"id" => "http://mastodon.example.org/users/admin/objects/1",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	},
	"to" => ["https://www.w3.org/ns/activitystreams#Public"]
	}

	{:ok, local_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "find me!"})
	{:ok, japanese_activity} = Pleroma.Web.CommonAPI.post(user, %{status: "更新情報"})
	{:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
	{:ok, remote_activity} = ObanHelpers.perform(job)
	remote_activity = Activity.get_by_id_with_object(remote_activity.id)

	%{
	japanese_activity: japanese_activity,
	local_activity: local_activity,
	remote_activity: remote_activity,
	user: user
	}
	end

	setup do: clear_config([:instance, :limit_to_local_content])

	+ @tag :skip_darwin
	test "finds utf8 text in statuses", %{
	japanese_activity: japanese_activity,
	user: user
	} do
	activities = Activity.search(user, "更新情報")

	assert [^japanese_activity] = activities
	end

	test "find local and remote statuses for authenticated users", %{
	local_activity: local_activity,
	remote_activity: remote_activity,
	user: user
	} do
	activities = Enum.sort_by(Activity.search(user, "find me"), & &1.id)

	assert [^local_activity, ^remote_activity] = activities
	end

	test "find only local statuses for unauthenticated users", %{local_activity: local_activity} do
	assert [^local_activity] = Activity.search(nil, "find me")
	end

	test "find only local statuses for unauthenticated users when `limit_to_local_content` is `:all`",
	%{local_activity: local_activity} do
	clear_config([:instance, :limit_to_local_content], :all)
	assert [^local_activity] = Activity.search(nil, "find me")
	end

	test "find all statuses for unauthenticated users when `limit_to_local_content` is `false`",
	%{
	local_activity: local_activity,
	remote_activity: remote_activity
	} do
	clear_config([:instance, :limit_to_local_content], false)

	activities = Enum.sort_by(Activity.search(nil, "find me"), & &1.id)

	assert [^local_activity, ^remote_activity] = activities
	end
	end

	test "all_by_ids_with_object/1" do
	%{id: id1} = insert(:note_activity)
	%{id: id2} = insert(:note_activity)

	activities =
	[id1, id2]
	\|> Activity.all_by_ids_with_object()
	\|> Enum.sort(&(&1.id < &2.id))

	assert [%{id: ^id1, object: %Object{}}, %{id: ^id2, object: %Object{}}] = activities
	end

	test "get_by_id_with_user_actor/1" do
	user = insert(:user)
	activity = insert(:note_activity, note: insert(:note, user: user))

	assert Activity.get_by_id_with_user_actor(activity.id).user_actor == user
	end

	test "get_by_id_with_object/1" do
	%{id: id} = insert(:note_activity)

	assert %Activity{id: ^id, object: %Object{}} = Activity.get_by_id_with_object(id)
	end

	test "get_by_ap_id_with_object/1" do
	%{data: %{"id" => ap_id}} = insert(:note_activity)

	assert %Activity{data: %{"id" => ^ap_id}, object: %Object{}} =
	Activity.get_by_ap_id_with_object(ap_id)
	end

	test "get_by_id/1" do
	%{id: id} = insert(:note_activity)

	assert %Activity{id: ^id} = Activity.get_by_id(id)
	end

	test "all_by_actor_and_id/2" do
	user = insert(:user)

	{:ok, %{id: id1}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})
	{:ok, %{id: id2}} = Pleroma.Web.CommonAPI.post(user, %{status: "cofefe"})

	assert [] == Activity.all_by_actor_and_id(user, [])

	activities =
	user.ap_id
	\|> Activity.all_by_actor_and_id([id1, id2])
	\|> Enum.sort(&(&1.id < &2.id))

	assert [%Activity{id: ^id1}, %Activity{id: ^id2}] = activities
	end

	test "get_by_object_ap_id_with_object/1" do
	user = insert(:user)
	another = insert(:user)

	{:ok, %{id: id, object: %{data: %{"id" => obj_id}}}} =
	Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Web.CommonAPI.favorite(another, id)

	assert obj_id
	\|> Pleroma.Activity.Queries.by_object_id()
	\|> Repo.aggregate(:count, :id) == 2

	assert %{id: ^id} = Activity.get_by_object_ap_id_with_object(obj_id)
	end

	test "add_by_params_query/3" do
	user = insert(:user)

	note = insert(:note_activity, user: user)

	insert(:add_activity, user: user, note: note)
	insert(:add_activity, user: user, note: note)
	insert(:add_activity, user: user)

	assert Repo.aggregate(Activity, :count, :id) == 4

	add_query =
	Activity.add_by_params_query(note.data["object"], user.ap_id, user.featured_address)

	assert Repo.aggregate(add_query, :count, :id) == 2

	Repo.delete_all(add_query)
	assert Repo.aggregate(add_query, :count, :id) == 0

	assert Repo.aggregate(Activity, :count, :id) == 2
	end

	describe "associated_object_id() sql function" do
	test "with json object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {"id":"foobar"}}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "with string object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": "foobar"}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "with array object" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": ["foobar", {}]}'::jsonb);
	"""
	)

	assert object_id == "foobar"
	end

	test "invalid" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {}}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end

	test "invalid object id" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{"object": {"id": 123}}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end

	test "no object field" do
	%{rows: [[object_id]]} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"""
	select associated_object_id('{}'::jsonb);
	"""
	)

	assert is_nil(object_id)
	end
	end
	end
	diff --git a/test/pleroma/config/deprecation_warnings_test.exs b/test/pleroma/config/deprecation_warnings_test.exs
	index 9a482e46e..fca2324ff 100644
	--- a/test/pleroma/config/deprecation_warnings_test.exs
	+++ b/test/pleroma/config/deprecation_warnings_test.exs
	@@ -1,392 +1,391 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.DeprecationWarningsTest do
	use ExUnit.Case
	use Pleroma.Tests.Helpers

	import ExUnit.CaptureLog

	alias Pleroma.Config
	alias Pleroma.Config.DeprecationWarnings

	describe "filter exiftool" do
	test "gives warning when still used" do
	clear_config(
	[Pleroma.Upload, :filters],
	[Pleroma.Upload.Filter.Exiftool]
	)

	assert capture_log(fn -> DeprecationWarnings.check_exiftool_filter() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using Exiftool as a filter instead of Exiftool.StripLocation. This should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool]
	```

	Is now


	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool.StripLocation]
	```
	"""
	end

	test "changes setting to exiftool strip location" do
	clear_config(
	[Pleroma.Upload, :filters],
	[Pleroma.Upload.Filter.Exiftool, Pleroma.Upload.Filter.Exiftool.ReadDescription]
	)

	expected_config = [
	Pleroma.Upload.Filter.Exiftool.StripLocation,
	Pleroma.Upload.Filter.Exiftool.ReadDescription
	]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([Pleroma.Upload]) \|> Keyword.get(:filters, []) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config(
	[Pleroma.Upload, :filters],
	[
	Pleroma.Upload.Filter.Exiftool.StripLocation,
	Pleroma.Upload.Filter.Exiftool.ReadDescription
	]
	)

	assert capture_log(fn -> DeprecationWarnings.check_exiftool_filter() end) == ""
	end
	end

	describe "simple policy tuples" do
	test "gives warning when there are still strings" do
	clear_config([:mrf_simple],
	media_removal: ["some.removal"],
	media_nsfw: ["some.nsfw"],
	federated_timeline_removal: ["some.tl.removal"],
	report_removal: ["some.report.removal"],
	reject: ["some.reject"],
	followers_only: ["some.followers.only"],
	accept: ["some.accept"],
	avatar_removal: ["some.avatar.removal"],
	banner_removal: ["some.banner.removal"],
	reject_deletes: ["some.reject.deletes"]
	)

	assert capture_log(fn -> DeprecationWarnings.check_simple_policy_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the SimplePolicy configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf_simple,
	media_removal: ["instance.tld"],
	media_nsfw: ["instance.tld"],
	federated_timeline_removal: ["instance.tld"],
	report_removal: ["instance.tld"],
	reject: ["instance.tld"],
	followers_only: ["instance.tld"],
	accept: ["instance.tld"],
	avatar_removal: ["instance.tld"],
	banner_removal: ["instance.tld"],
	reject_deletes: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf_simple,
	media_removal: [{"instance.tld", "Reason for media removal"}],
	media_nsfw: [{"instance.tld", "Reason for media nsfw"}],
	federated_timeline_removal: [{"instance.tld", "Reason for federated timeline removal"}],
	report_removal: [{"instance.tld", "Reason for report removal"}],
	reject: [{"instance.tld", "Reason for reject"}],
	followers_only: [{"instance.tld", "Reason for followers only"}],
	accept: [{"instance.tld", "Reason for accept"}],
	avatar_removal: [{"instance.tld", "Reason for avatar removal"}],
	banner_removal: [{"instance.tld", "Reason for banner removal"}],
	reject_deletes: [{"instance.tld", "Reason for reject deletes"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:mrf_simple],
	media_removal: ["some.removal", {"some.other.instance", "Some reason"}]
	)

	- expected_config = [
	+ expected_config =
	{:media_removal, [{"some.removal", ""}, {"some.other.instance", "Some reason"}]}
	- ]

	capture_log(fn -> DeprecationWarnings.warn() end)

	- assert Config.get([:mrf_simple]) == expected_config
	+ assert expected_config in Config.get([:mrf_simple])
	end

	test "doesn't give a warning with correct config" do
	clear_config([:mrf_simple],
	media_removal: [{"some.removal", ""}, {"some.other.instance", "Some reason"}]
	)

	assert capture_log(fn -> DeprecationWarnings.check_simple_policy_tuples() end) == ""
	end
	end

	describe "quarantined_instances tuples" do
	test "gives warning when there are still strings" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	"somedomain.tld"
	])

	assert capture_log(fn -> DeprecationWarnings.check_quarantined_instances_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the quarantined_instances configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :instance,
	quarantined_instances: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :instance,
	quarantined_instances: [{"instance.tld", "Reason for quarantine"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	"some.tld"
	])

	expected_config = [{"domain.com", "some reason"}, {"some.tld", ""}]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([:instance, :quarantined_instances]) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	{"some.tld", ""}
	])

	assert capture_log(fn -> DeprecationWarnings.check_quarantined_instances_tuples() end) == ""
	end
	end

	describe "transparency_exclusions tuples" do
	test "gives warning when there are still strings" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	"somedomain.tld"
	])

	assert capture_log(fn -> DeprecationWarnings.check_transparency_exclusions_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the transparency_exclusions configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf,
	transparency_exclusions: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf,
	transparency_exclusions: [{"instance.tld", "Reason to exclude transparency"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	"some.tld"
	])

	expected_config = [{"domain.com", "some reason"}, {"some.tld", ""}]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([:mrf, :transparency_exclusions]) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	{"some.tld", ""}
	])

	assert capture_log(fn -> DeprecationWarnings.check_transparency_exclusions_tuples() end) ==
	""
	end
	end

	test "check_old_mrf_config/0" do
	clear_config([:instance, :rewrite_policy], [])
	clear_config([:instance, :mrf_transparency], true)
	clear_config([:instance, :mrf_transparency_exclusions], [])

	assert capture_log(fn -> DeprecationWarnings.check_old_mrf_config() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using old namespaces for MRF configuration. They should work for now, but you are advised to change to new namespaces to prevent possible issues later:

	* `config :pleroma, :instance, rewrite_policy` is now `config :pleroma, :mrf, policies`
	* `config :pleroma, :instance, mrf_transparency` is now `config :pleroma, :mrf, transparency`
	* `config :pleroma, :instance, mrf_transparency_exclusions` is now `config :pleroma, :mrf, transparency_exclusions`
	"""
	end

	test "move_namespace_and_warn/2" do
	old_group1 = [:group, :key]
	old_group2 = [:group, :key2]
	old_group3 = [:group, :key3]

	new_group1 = [:another_group, :key4]
	new_group2 = [:another_group, :key5]
	new_group3 = [:another_group, :key6]

	clear_config(old_group1, 1)
	clear_config(old_group2, 2)
	clear_config(old_group3, 3)

	clear_config(new_group1)
	clear_config(new_group2)
	clear_config(new_group3)

	config_map = [
	{old_group1, new_group1, "\n error :key"},
	{old_group2, new_group2, "\n error :key2"},
	{old_group3, new_group3, "\n error :key3"}
	]

	assert capture_log(fn ->
	DeprecationWarnings.move_namespace_and_warn(
	config_map,
	"Warning preface"
	)
	end) =~ "Warning preface\n error :key\n error :key2\n error :key3"

	assert Config.get(new_group1) == 1
	assert Config.get(new_group2) == 2
	assert Config.get(new_group3) == 3
	end

	test "check_media_proxy_whitelist_config/0" do
	clear_config([:media_proxy, :whitelist], ["https://example.com", "example2.com"])

	assert capture_log(fn ->
	DeprecationWarnings.check_media_proxy_whitelist_config()
	end) =~ "Your config is using old format (only domain) for MediaProxy whitelist option"
	end

	test "check_welcome_message_config/0" do
	clear_config([:instance, :welcome_user_nickname], "LainChan")

	assert capture_log(fn ->
	DeprecationWarnings.check_welcome_message_config()
	end) =~ "Your config is using the old namespace for Welcome messages configuration."
	end

	test "check_hellthread_threshold/0" do
	clear_config([:mrf_hellthread, :threshold], 16)

	assert capture_log(fn ->
	DeprecationWarnings.check_hellthread_threshold()
	end) =~ "You are using the old configuration mechanism for the hellthread filter."
	end

	test "check_activity_expiration_config/0" do
	clear_config([Pleroma.ActivityExpiration], enabled: true)

	assert capture_log(fn ->
	DeprecationWarnings.check_activity_expiration_config()
	end) =~ "Your config is using old namespace for activity expiration configuration."
	end

	test "check_uploaders_s3_public_endpoint/0" do
	clear_config([Pleroma.Uploaders.S3], public_endpoint: "https://fake.amazonaws.com/bucket/")

	assert capture_log(fn ->
	DeprecationWarnings.check_uploaders_s3_public_endpoint()
	end) =~
	"Your config is using the old setting for controlling the URL of media uploaded to your S3 bucket."
	end

	describe "check_gun_pool_options/0" do
	test "await_up_timeout" do
	config = Config.get(:connections_pool)
	clear_config(:connections_pool, Keyword.put(config, :await_up_timeout, 5_000))

	assert capture_log(fn ->
	DeprecationWarnings.check_gun_pool_options()
	end) =~
	"Your config is using old setting `config :pleroma, :connections_pool, await_up_timeout`."
	end

	test "pool timeout" do
	old_config = [
	federation: [
	size: 50,
	max_waiting: 10,
	timeout: 10_000
	],
	media: [
	size: 50,
	max_waiting: 10,
	timeout: 10_000
	],
	upload: [
	size: 25,
	max_waiting: 5,
	timeout: 15_000
	],
	default: [
	size: 10,
	max_waiting: 2,
	timeout: 5_000
	]
	]

	clear_config(:pools, old_config)

	assert capture_log(fn ->
	DeprecationWarnings.check_gun_pool_options()
	end) =~
	"Your config is using old setting name `timeout` instead of `recv_timeout` in pool settings"
	end
	end

	test "check_old_chat_shoutbox/0" do
	clear_config([:instance, :chat_limit], 1_000)
	clear_config([:chat, :enabled], true)

	assert capture_log(fn ->
	DeprecationWarnings.check_old_chat_shoutbox()
	end) =~
	"Your config is using the old namespace for the Shoutbox configuration."
	end
	end
	diff --git a/test/pleroma/healthcheck_test.exs b/test/pleroma/healthcheck_test.exs
	index 733537f02..a8ab865ac 100644
	--- a/test/pleroma/healthcheck_test.exs
	+++ b/test/pleroma/healthcheck_test.exs
	@@ -1,33 +1,35 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HealthcheckTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Healthcheck

	test "system_info/0" do
	result = Healthcheck.system_info() \|> Map.from_struct()

	- assert Map.keys(result) == [
	+ keys = Map.keys(result)
	+
	+ assert Keyword.equal?(keys, [
	: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 "check_health/1" do
	result = Healthcheck.check_health(%Healthcheck{pool_size: 10, active: 9})
	assert result.healthy
	end
	end
	end
	diff --git a/test/pleroma/mfa/totp_test.exs b/test/pleroma/mfa/totp_test.exs
	index 56e4f48ed..f291ed14b 100644
	--- a/test/pleroma/mfa/totp_test.exs
	+++ b/test/pleroma/mfa/totp_test.exs
	@@ -1,21 +1,25 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFA.TOTPTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.MFA.TOTP

	+ import Pleroma.Tests.Helpers, only: [uri_equal?: 2]
	+
	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 ==
	+ assert uri_equal?(
	+ uri,
	"otpauth://totp/test@example.com?digits=8&issuer=Plerome-42&period=60&secret=test-secrcet"
	+ )
	end
	end
	diff --git a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	index 52a606368..9847781f0 100644
	--- a/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	+++ b/test/pleroma/repo/migrations/autolinker_to_linkify_test.exs
	@@ -1,72 +1,72 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.AutolinkerToLinkifyTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	setup do: clear_config(Pleroma.Formatter)
	setup_all do: require_migration("20200716195806_autolinker_to_linkify")

	test "change/0 converts auto_linker opts for Pleroma.Formatter", %{migration: migration} do
	autolinker_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "testing"
	]

	insert(:config, group: :auto_linker, key: :opts, value: autolinker_opts)

	migration.change()

	assert nil == ConfigDB.get_by_params(%{group: :auto_linker, key: :opts})

	%{value: new_opts} = ConfigDB.get_by_params(%{group: :pleroma, key: Pleroma.Formatter})

	- assert new_opts == [
	+ assert Keyword.equal?(new_opts,
	class: false,
	extra: true,
	new_window: false,
	rel: "testing",
	strip_prefix: false
	- ]
	+ )

	clear_config(Pleroma.Formatter, new_opts)
	assert new_opts == Pleroma.Config.get(Pleroma.Formatter)

	{text, _mentions, []} =
	Pleroma.Formatter.linkify(
	"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\n\nOmg will COVID finally end Black Friday???"
	)

	assert text ==
	"<a href=\"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\" rel=\"testing\">https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7</a>\n\nOmg will COVID finally end Black Friday???"
	end

	test "transform_opts/1 returns a list of compatible opts", %{migration: migration} do
	old_opts = [
	extra: true,
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "qqq"
	]

	expected_opts = [
	class: false,
	extra: true,
	new_window: false,
	rel: "qqq",
	strip_prefix: false
	]

	- assert migration.transform_opts(old_opts) == expected_opts
	+ assert Keyword.equal?(migration.transform_opts(old_opts), expected_opts)
	end
	end
	diff --git a/test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs b/test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs
	index 4c45adb4b..cf3fe5aac 100644
	--- a/test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs
	+++ b/test/pleroma/repo/migrations/fix_malformed_formatter_config_test.exs
	@@ -1,70 +1,70 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo.Migrations.FixMalformedFormatterConfigTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	import Pleroma.Tests.Helpers
	alias Pleroma.ConfigDB

	setup do: clear_config(Pleroma.Formatter)
	setup_all do: require_migration("20200722185515_fix_malformed_formatter_config")

	test "change/0 converts a map into a list", %{migration: migration} do
	incorrect_opts = %{
	class: false,
	extra: true,
	new_window: false,
	rel: "F",
	strip_prefix: false
	}

	insert(:config, group: :pleroma, key: Pleroma.Formatter, value: incorrect_opts)

	assert :ok == migration.change()

	%{value: new_opts} = ConfigDB.get_by_params(%{group: :pleroma, key: Pleroma.Formatter})

	- assert new_opts == [
	+ assert Keyword.equal?(new_opts,
	class: false,
	extra: true,
	new_window: false,
	rel: "F",
	strip_prefix: false
	- ]
	+ )

	clear_config(Pleroma.Formatter, new_opts)
	assert new_opts == Pleroma.Config.get(Pleroma.Formatter)

	{text, _mentions, []} =
	Pleroma.Formatter.linkify(
	"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\n\nOmg will COVID finally end Black Friday???"
	)

	assert text ==
	"<a href=\"https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7\" rel=\"F\">https://www.businessinsider.com/walmart-will-close-stores-on-thanksgiving-ending-black-friday-tradition-2020-7</a>\n\nOmg will COVID finally end Black Friday???"
	end

	test "change/0 skips if Pleroma.Formatter config is already a list", %{migration: migration} do
	opts = [
	class: false,
	extra: true,
	new_window: false,
	rel: "ugc",
	strip_prefix: false
	]

	insert(:config, group: :pleroma, key: Pleroma.Formatter, value: opts)

	assert :skipped == migration.change()

	%{value: new_opts} = ConfigDB.get_by_params(%{group: :pleroma, key: Pleroma.Formatter})

	assert new_opts == opts
	end

	test "change/0 skips if Pleroma.Formatter is empty", %{migration: migration} do
	assert :skipped == migration.change()
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	index 3654c6b20..b05487abe 100644
	--- a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,459 +1,460 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	:ok
	end

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

	describe ".search2" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v2/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

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

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

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

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

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
	\|> json_response_and_validate_schema(200)

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

	assert results["hashtags"] == [
	%{"name" => "private", "url" => "#{Endpoint.url()}/tag/private"}
	]

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

	results =
	get(conn, "/api/v2/search?q=天子")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "天子", "url" => "#{Endpoint.url()}/tag/天子"}
	]

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

	test "search local-only status as an authenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access(["read:search"])

	{:ok, activity} =
	CommonAPI.post(user, %{status: "This is about 2hu private 天子", visibility: "local"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

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

	test "search local-only status as an unauthenticated user" do
	user = insert(:user)
	%{conn: conn} = oauth_access([])

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

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	test "search local-only status as an anonymous user" do
	user = insert(:user)

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

	results =
	build_conn()
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu"})}")
	\|> json_response_and_validate_schema(200)

	assert [] = results["statuses"]
	end

	@tag capture_log: true
	test "constructs hashtags from search query", %{conn: conn} do
	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "explicit", "url" => "#{Endpoint.url()}/tag/explicit"},
	%{"name" => "hashtags", "url" => "#{Endpoint.url()}/tag/hashtags"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "john", "url" => "#{Endpoint.url()}/tag/john"},
	%{"name" => "doe", "url" => "#{Endpoint.url()}/tag/doe"},
	%{"name" => "JohnDoe", "url" => "#{Endpoint.url()}/tag/JohnDoe"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "accident", "url" => "#{Endpoint.url()}/tag/accident"},
	%{"name" => "prone", "url" => "#{Endpoint.url()}/tag/prone"},
	%{"name" => "AccidentProne", "url" => "#{Endpoint.url()}/tag/AccidentProne"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "shpuld", "url" => "#{Endpoint.url()}/tag/shpuld"}
	]

	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "https://www.washingtonpost.com/sports/2020/06/10/" <> "nascar-ban-display-confederate-flag-all-events-properties/"})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "nascar", "url" => "#{Endpoint.url()}/tag/nascar"},
	%{"name" => "ban", "url" => "#{Endpoint.url()}/tag/ban"},
	%{"name" => "display", "url" => "#{Endpoint.url()}/tag/display"},
	%{"name" => "confederate", "url" => "#{Endpoint.url()}/tag/confederate"},
	%{"name" => "flag", "url" => "#{Endpoint.url()}/tag/flag"},
	%{"name" => "all", "url" => "#{Endpoint.url()}/tag/all"},
	%{"name" => "events", "url" => "#{Endpoint.url()}/tag/events"},
	%{"name" => "properties", "url" => "#{Endpoint.url()}/tag/properties"},
	%{
	"name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
	"url" =>
	"#{Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	}
	]
	end

	test "supports pagination of hashtags search results", %{conn: conn} do
	results =
	conn
	\|> get(
	"/api/v2/search?#{URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	%{"name" => "text", "url" => "#{Endpoint.url()}/tag/text"},
	%{"name" => "with", "url" => "#{Endpoint.url()}/tag/with"}
	]
	end

	test "excludes a blocked users from search results", %{conn: conn} do
	user = insert(:user)
	user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
	user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})

	{:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
	{:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
	{:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
	Pleroma.User.block(user, user_smith)

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v2/search?q=Agent")
	\|> json_response_and_validate_schema(200)

	status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)

	assert act3.id in status_ids
	refute act2.id in status_ids
	refute act1.id in status_ids
	end
	end

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

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp")
	\|> json_response_and_validate_schema(200)

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

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

	results =
	conn
	\|> get("/api/v1/accounts/search?q=2hu")
	\|> json_response_and_validate_schema(200)

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

	assert user_three.nickname in result_ids
	end

	test "returns account if query contains a space", %{conn: conn} do
	insert(:user, %{nickname: "shp@shitposter.club"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
	\|> json_response_and_validate_schema(200)

	assert length(results) == 1
	end
	end

	describe ".search" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

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

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

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

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

	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

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

	assert results["hashtags"] == ["2hu"]

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

	test "search fetches remote statuses and prefers them over other results", %{conn: conn} 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)

	capture_log(fn ->
	{:ok, %{id: activity_id}} =
	CommonAPI.post(insert(:user), %{
	status: "check out http://mastodon.example.org/@admin/99541947525187367"
	})

	results =
	conn
	\|> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"url" => "http://mastodon.example.org/@admin/99541947525187367"},
	%{"id" => ^activity_id}
	] = results["statuses"]
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	capture_log(fn ->
	q = Object.normalize(activity, fetch: false).data["id"]

	results =
	conn
	\|> get("/api/v1/search?q=#{q}")
	\|> json_response_and_validate_schema(200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	user = insert(:user)

	query = URI.encode_query(%{q: " mike@osada.macgirvin.com ", resolve: true})

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v1/search?#{query}")
	\|> json_response_and_validate_schema(200)

	[account] = results["accounts"]
	assert account["acct"] == "mike@osada.macgirvin.com"
	end

	test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
	results =
	conn
	\|> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
	\|> json_response_and_validate_schema(200)

	assert [] == results["accounts"]
	end

	test "search with limit and offset", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	_user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

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

	result =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1")

	assert results = json_response_and_validate_schema(result, 200)
	assert [%{"id" => activity_id1}] = results["statuses"]
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1&offset=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert [] = results["accounts"]

	assert activity_id1 != activity_id2
	end

	test "search returns results only for the given type", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

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

	assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=statuses")
	\|> json_response_and_validate_schema(200)

	assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=accounts")
	\|> json_response_and_validate_schema(200)
	end

	test "search uses account_id to filter statuses by the author", %{conn: conn} do
	user = insert(:user, %{nickname: "shp@shitposter.club"})
	user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id1}] = results["statuses"]
	assert activity_id1 == activity1.id
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert activity_id2 == activity2.id
	end
	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 4e3d34172..7bbe46cbe 100644
	--- a/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,2555 +1,2559 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
	use Pleroma.Web.ConnCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.ModerationLog
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	+ alias Pleroma.Tests.Helpers
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.ScheduledActivityWorker

	import Mox
	import Pleroma.Factory

	setup do: clear_config([:instance, :federating])
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:mrf, :policies])
	setup do: clear_config([:mrf_keyword, :reject])

	setup do
	Pleroma.UnstubbedConfigMock
	\|> stub_with(Pleroma.Config)

	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> false
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	:ok
	end

	describe "posting statuses" do
	setup do: oauth_access(["write:statuses"])

	test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
	clear_config([:instance, :federating], true)
	clear_config([: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"
	})

	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
	})

	# Idempotency plug response means detection fail
	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 "posting a quote post", %{conn: conn} do
	user = insert(:user)

	{:ok, %{id: activity_id} = activity} = CommonAPI.post(user, %{status: "yolo"})
	%{data: %{"id" => quote_url}} = Object.normalize(activity)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "indeed",
	"quote_id" => activity_id
	})

	assert %{
	"id" => id,
	"pleroma" => %{"quote" => %{"id" => ^activity_id}, "quote_url" => ^quote_url}
	} = json_response_and_validate_schema(conn, 200)

	assert Activity.get_by_id(id)
	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
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([: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", "context"], nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> assign(:user, refresh_record(conn.assigns.user))
	\|> 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", "context"], 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
	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	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)

	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	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

	test "discloses application metadata when enabled" do
	user = insert(:user, disclose_client: true)
	%{user: _user, token: token, conn: conn} = oauth_access(["write:statuses"], user: user)

	%Pleroma.Web.OAuth.Token{
	app: %Pleroma.Web.OAuth.App{
	client_name: app_name,
	website: app_website
	}
	} = token

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "cofe is my copilot"
	})

	assert %{
	"content" => "cofe is my copilot"
	} = json_response_and_validate_schema(result, 200)

	activity = result.assigns.activity.id

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

	assert %{
	"content" => "cofe is my copilot",
	"application" => %{
	"name" => ^app_name,
	"website" => ^app_website
	}
	} = json_response_and_validate_schema(result, 200)
	end

	test "hides application metadata when disabled" do
	user = insert(:user, disclose_client: false)
	%{user: _user, token: _token, conn: conn} = oauth_access(["write:statuses"], user: user)

	result =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "club mate is my wingman"
	})

	assert %{"content" => "club mate is my wingman"} =
	json_response_and_validate_schema(result, 200)

	activity = result.assigns.activity.id

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

	assert %{
	"content" => "club mate is my wingman",
	"application" => nil
	} = json_response_and_validate_schema(result, 200)
	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 "with expiration" do
	%{conn: conn} = oauth_access(["write:statuses", "read:statuses"])

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	assert %{"id" => status_id, "params" => %{"expires_in" => 300}} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at,
	"expires_in" => 300
	})
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^status_id, "params" => %{"expires_in" => 300}} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/scheduled_statuses/#{status_id}")
	\|> json_response_and_validate_schema(200)
	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
	assert response["poll"]["expired"] == false

	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 num -> "desu #{num}" 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" => [String.duplicate(".", limit + 1), "lol"],
	"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

	test "scheduled poll", %{conn: conn} do
	clear_config([ScheduledActivity, :enabled], true)

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()
	\|> Kernel.<>("Z")

	%{"id" => scheduled_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "very cool poll",
	"poll" => %{
	"options" => ~w(a b c),
	"expires_in" => 420
	},
	"scheduled_at" => scheduled_at
	})
	\|> json_response_and_validate_schema(200)

	assert {:ok, %{id: activity_id}} =
	perform_job(ScheduledActivityWorker, %{
	activity_id: scheduled_id
	})

	refute_enqueued(worker: ScheduledActivityWorker)

	object =
	Activity
	\|> Repo.get(activity_id)
	\|> Object.normalize()

	assert object.data["content"] == "very cool poll"
	assert object.data["type"] == "Question"
	assert length(object.data["oneOf"]) == 3
	end

	test "cannot have only one option", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => ["mew"], "expires_in" => 1}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll must contain at least 2 options"
	end

	test "cannot have only duplicated options", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => ["mew", "mew"], "expires_in" => 1}
	})

	%{"error" => error} = json_response_and_validate_schema(conn, 422)
	assert error == "Poll must contain at least 2 options"
	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

	defp local_and_remote_context_activities do
	local_user_1 = insert(:user)
	local_user_2 = insert(:user)
	remote_user = insert(:user, local: false)

	{:ok, %{id: id1, data: %{"context" => context}}} =
	CommonAPI.post(local_user_1, %{status: "post"})

	{:ok, %{id: id2} = post} =
	CommonAPI.post(local_user_2, %{status: "local reply", in_reply_to_status_id: id1})

	params = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_user.ap_id,
	"type" => "Create",
	"context" => context,
	"id" => "#{remote_user.ap_id}/activities/1",
	"inReplyTo" => post.data["id"],
	"object" => %{
	"type" => "Note",
	"content" => "remote reply",
	"context" => context,
	"id" => "#{remote_user.ap_id}/objects/1",
	"attributedTo" => remote_user.ap_id,
	"to" => [
	local_user_1.ap_id,
	local_user_2.ap_id,
	"https://www.w3.org/ns/activitystreams#Public"
	]
	},
	"to" => [
	local_user_1.ap_id,
	local_user_2.ap_id,
	"https://www.w3.org/ns/activitystreams#Public"
	]
	}

	{:ok, job} = Pleroma.Web.Federator.incoming_ap_doc(params)
	{:ok, remote_activity} = ObanHelpers.perform(job)

	%{locals: [id1, id2], remote: remote_activity.id, context: context}
	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 "getting status contexts restricted unauthenticated for local and remote" do
	setup do: local_and_remote_context_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, locals: [post_id, _]} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	assert json_response_and_validate_schema(res_conn, 200) == %{
	"ancestors" => [],
	"descendants" => []
	}
	end

	test "if user is unauthenticated reply", %{conn: conn, locals: [_, reply_id]} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	assert json_response_and_validate_schema(res_conn, 200) == %{
	"ancestors" => [],
	"descendants" => []
	}
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	end
	end

	describe "getting status contexts restricted unauthenticated for local" do
	setup do: local_and_remote_context_activities()

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

	setup do: clear_config([:restrict_unauthenticated, :activities, :remote], false)

	test "if user is unauthenticated", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id not in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is unauthenticated reply", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id not in ancestor_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id in descendant_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	end
	end

	describe "getting status contexts restricted unauthenticated for remote" do
	setup do: local_and_remote_context_activities()

	setup do: clear_config([:restrict_unauthenticated, :activities, :local], false)

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

	test "if user is unauthenticated", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in descendant_ids
	assert remote_reply_id not in descendant_ids
	end

	test "if user is unauthenticated reply", %{
	conn: conn,
	locals: [post_id, reply_id],
	remote: remote_reply_id
	} do
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id not in descendant_ids
	end

	test "if user is authenticated", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{post_id}/context")

	%{"ancestors" => [], "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	reply_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert reply_id in reply_ids
	assert remote_reply_id in reply_ids
	end

	test "if user is authenticated reply", %{locals: [post_id, reply_id], remote: remote_reply_id} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{reply_id}/context")

	%{"ancestors" => ancestors, "descendants" => descendants} =
	json_response_and_validate_schema(res_conn, 200)

	ancestor_ids =
	ancestors
	\|> Enum.map(& &1["id"])

	descendant_ids =
	descendants
	\|> Enum.map(& &1["id"])

	assert post_id in ancestor_ids
	assert remote_reply_id in descendant_ids
	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, fetch: false)

	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 privileged to", %{conn: conn} do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	activity = insert(:note_activity)
	user = insert(:user, is_moderator: true)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	assert ModerationLog \|> Repo.one() \|> ModerationLog.get_log_entry_message() ==
	"@#{user.nickname} deleted status ##{activity.id}"

	refute Activity.get_by_id(activity.id)
	end

	test "when you're privileged and the user is banned", %{conn: conn} do
	clear_config([:instance, :moderator_privileges], [:messages_delete])
	posting_user = insert(:user, is_active: false)
	refute posting_user.is_active
	activity = insert(:note_activity, user: posting_user)
	user = insert(:user, is_moderator: true)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response_and_validate_schema(res_conn, 200)

	assert ModerationLog \|> Repo.one() \|> ModerationLog.get_log_entry_message() ==
	"@#{user.nickname} deleted status ##{activity.id}"

	refute Activity.get_by_id(activity.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

	test "author can reblog own private status", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe", visibility: "private"})

	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,
	"visibility" => "private"
	} = json_response_and_validate_schema(conn, 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 = activity.id

	assert %{"id" => ^id, "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, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "non authenticated user", %{activity: activity} do
	assert build_conn()
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(403) == %{"error" => "Invalid credentials."}
	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, 422) == %{
	"error" => "Non-public status cannot be pinned"
	}
	end

	test "pin by another user", %{activity: activity} do
	%{conn: conn} = oauth_access(["write:accounts"])

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(422) == %{"error" => "Someone else's status cannot be pinned"}
	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 404 error when activity doesn't exist", %{conn: conn} do
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/statuses/1/unpin")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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
	Pleroma.StaticStubbedConfigMock
	\|> stub(:get, fn
	[:rich_media, :enabled] -> true
	path -> Pleroma.Test.StaticConfig.get(path)
	end)

	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, fetch: false).data["inReplyTo"] ==
	Object.normalize(replied_to, fetch: false).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_and_validate_schema(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)
	+ [next_url, _next_rel] = String.split(next, ";")
	+ next_url = String.trim_trailing(next_url, ">") \|> String.trim_leading("<")
	+
	+ max_id = Helpers.get_query_parameter(next_url, "max_id")

	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

	describe "local-only statuses" do
	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 = Utils.as_local_public()

	assert %{"content" => "cofe", "id" => id, "visibility" => "local"} =
	json_response_and_validate_schema(conn_one, 200)

	assert %Activity{id: ^id, data: %{"to" => [^local]}} = Activity.get_by_id(id)
	end

	test "other users can read local-only posts" do
	user = insert(:user)
	%{user: _reader, conn: conn} = oauth_access(["read:statuses"])

	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

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

	assert received["id"] == activity.id
	end

	test "anonymous users cannot see local-only posts" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	_received =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	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

	describe "get status history" do
	setup do
	%{conn: build_conn()}
	end

	test "unedited post", %{conn: conn} do
	activity = insert(:note_activity)

	conn = get(conn, "/api/v1/statuses/#{activity.id}/history")

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

	test "edited post", %{conn: conn} do
	note =
	insert(
	:note,
	data: %{
	"formerRepresentations" => %{
	"type" => "OrderedCollection",
	"orderedItems" => [
	%{
	"type" => "Note",
	"content" => "mew mew 2",
	"summary" => "title 2"
	},
	%{
	"type" => "Note",
	"content" => "mew mew 1",
	"summary" => "title 1"
	}
	],
	"totalItems" => 2
	}
	}
	)

	activity = insert(:note_activity, note: note)

	conn = get(conn, "/api/v1/statuses/#{activity.id}/history")

	assert [%{"spoiler_text" => "title 1"}, %{"spoiler_text" => "title 2"}, _] =
	json_response_and_validate_schema(conn, 200)
	end
	end

	describe "get status source" do
	setup do
	%{conn: build_conn()}
	end

	test "it returns the source", %{conn: conn} do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

	conn = get(conn, "/api/v1/statuses/#{activity.id}/source")

	id = activity.id

	assert %{"id" => ^id, "text" => "mew mew #abc", "spoiler_text" => "#def"} =
	json_response_and_validate_schema(conn, 200)
	end
	end

	describe "update status" do
	setup do
	oauth_access(["write:statuses"])
	end

	test "it updates the status" do
	%{conn: conn, user: user} = oauth_access(["write:statuses", "read:statuses"])

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

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

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(200)

	assert response["content"] == "edited"
	assert response["spoiler_text"] == "lol"

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

	assert response["content"] == "edited"
	assert response["spoiler_text"] == "lol"
	end

	test "it updates the attachments", %{conn: conn, user: user} do
	attachment = insert(:attachment, user: user)
	attachment_id = to_string(attachment.id)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew mew #abc", spoiler_text: "#def"})

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "mew mew #abc",
	"spoiler_text" => "#def",
	"media_ids" => [attachment_id]
	})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^attachment_id}] = response["media_attachments"]
	end

	test "it does not update visibility", %{conn: conn, user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "mew mew #abc",
	spoiler_text: "#def",
	visibility: "private"
	})

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(200)

	assert response["visibility"] == "private"
	end

	test "it refuses to update when original post is not by the user", %{conn: conn} do
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{status: "mew mew #abc", spoiler_text: "#def"})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(:forbidden)
	end

	test "it returns 404 if the user cannot see the post", %{conn: conn} do
	another_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(another_user, %{
	status: "mew mew #abc",
	spoiler_text: "#def",
	visibility: "private"
	})

	conn
	\|> put_req_header("content-type", "application/json")
	\|> put("/api/v1/statuses/#{activity.id}", %{
	"status" => "edited",
	"spoiler_text" => "lol"
	})
	\|> json_response_and_validate_schema(:not_found)
	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 ce7cfa9c7..837dc0dce 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,266 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SubscriptionControllerTest do
	- use Pleroma.Web.ConnCase, async: true
	+ use Pleroma.Web.ConnCase, async: false

	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
	+ setup do
	+ vapid_config = Application.get_env(:web_push_encryption, :vapid_details)
	+
	+ Application.put_env(:web_push_encryption, :vapid_details, [])
	+
	+ on_exit(fn -> Application.put_env(:web_push_encryption, :vapid_details, vapid_config) end)
	+ end
	+
	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/pleroma_api/controllers/chat_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	index 7138a6636..0d3452559 100644
	--- a/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/chat_controller_test.exs
	@@ -1,473 +1,501 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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.Tests.Helpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	import Mox
	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, fetch: 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, fetch: 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"
	}

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	{: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, fetch: 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, fetch: 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/"
	+ api_endpoint = Pleroma.Web.Endpoint.url() <> "/api/v1/pleroma/chats/"
	+
	+ [next_url, next_rel] = String.split(next, ";")
	+ next_url = String.trim_trailing(next_url, ">") \|> String.trim_leading("<")
	+
	+ next_url_sorted = Helpers.uri_query_sort(next_url)

	assert String.match?(
	- next,
	- ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.; rel=\"next\"$)
	+ next_url_sorted,
	+ ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.&offset=\d+$)
	)

	+ assert next_rel =~ "next"
	+
	+ [prev_url, prev_rel] = String.split(prev, ";")
	+ prev_url = String.trim_trailing(prev_url, ">") \|> String.trim_leading("<")
	+
	+ prev_url_sorted = Helpers.uri_query_sort(prev_url)
	+
	assert String.match?(
	- prev,
	- ~r(#{api_endpoint}./messages\?limit=\d+&min_id=.; rel=\"prev\"$)
	+ prev_url_sorted,
	+ ~r(#{api_endpoint}./messages\?limit=\d+&min_id=.&offset=\d+$)
	)

	+ assert prev_rel =~ "prev"
	+
	assert length(result) == 20

	- response =
	- get(conn, "/api/v1/pleroma/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
	+ response = get(conn, "#{api_endpoint}#{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(", ")

	+ [next_url, next_rel] = String.split(next, ";")
	+ next_url = String.trim_trailing(next_url, ">") \|> String.trim_leading("<")
	+
	+ next_url_sorted = Helpers.uri_query_sort(next_url)
	+
	assert String.match?(
	- next,
	- ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.; rel=\"next\"$)
	+ next_url_sorted,
	+ ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.&offset=\d+$)
	)

	+ assert next_rel =~ "next"
	+
	+ [prev_url, prev_rel] = String.split(prev, ";")
	+ prev_url = String.trim_trailing(prev_url, ">") \|> String.trim_leading("<")
	+
	+ prev_url_sorted = Helpers.uri_query_sort(prev_url)
	+
	assert String.match?(
	- prev,
	- ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.&min_id=.*; rel=\"prev\"$)
	+ prev_url_sorted,
	+ ~r(#{api_endpoint}./messages\?limit=\d+&max_id=.&min_id=.*&offset=\d+$)
	)

	+ assert prev_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

	for tested_endpoint <- ["/api/v1/pleroma/chats", "/api/v2/pleroma/chats"] do
	describe "GET #{tested_endpoint}" 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(unquote(tested_endpoint))
	\|> 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(unquote(tested_endpoint))
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1

	User.block(user, recipient)

	result =
	conn
	\|> get(unquote(tested_endpoint))
	\|> 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(unquote(tested_endpoint))
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1

	User.mute(user, recipient)

	result =
	conn
	\|> get(unquote(tested_endpoint))
	\|> json_response_and_validate_schema(200)

	assert length(result) == 0

	result =
	conn
	\|> get("#{unquote(tested_endpoint)}?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 1
	end

	if tested_endpoint == "/api/v1/pleroma/chats" do
	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(unquote(tested_endpoint))
	\|> json_response_and_validate_schema(200)

	assert length(result) == 30
	end
	else
	test "it paginates 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(unquote(tested_endpoint))
	\|> json_response_and_validate_schema(200)

	assert length(result) == 20
	last_id = List.last(result)["id"]

	result =
	conn
	\|> get(unquote(tested_endpoint) <> "?max_id=#{last_id}")
	\|> json_response_and_validate_schema(200)

	assert length(result) == 10
	end
	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)
	{: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)
	{: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(unquote(tested_endpoint))
	\|> 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(unquote(tested_endpoint))
	\|> 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
	end
	diff --git a/test/pleroma/web/web_finger/web_finger_controller_test.exs b/test/pleroma/web/web_finger/web_finger_controller_test.exs
	index e01cec5e4..80e072163 100644
	--- a/test/pleroma/web/web_finger/web_finger_controller_test.exs
	+++ b/test/pleroma/web/web_finger/web_finger_controller_test.exs
	@@ -1,137 +1,132 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFinger.WebFingerControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock

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

	setup_all do: clear_config([:instance, :federating], true)

	test "GET host-meta" do
	response =
	build_conn()
	\|> get("/.well-known/host-meta")

	assert response.status == 200

	- assert response.resp_body ==
	- ~s(<?xml version="1.0" encoding="UTF-8"?><XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0"><Link rel="lrdd" template="#{Pleroma.Web.Endpoint.url()}/.well-known/webfinger?resource={uri}" type="application/xrd+xml" /></XRD>)
	+ response_xml =
	+ response.resp_body
	+ \|> Floki.parse_document!(html_parser: Floki.HTMLParser.Mochiweb, attributes_as_maps: true)
	+
	+ expected_xml =
	+ ~s(<?xml version="1.0" encoding="UTF-8"?><XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0"><Link rel="lrdd" template="#{Pleroma.Web.Endpoint.url()}/.well-known/webfinger?resource={uri}" type="application/xrd+xml" /></XRD>)
	+ \|> Floki.parse_document!(html_parser: Floki.HTMLParser.Mochiweb, attributes_as_maps: true)
	+
	+ assert match?(^response_xml, expected_xml)
	end

	test "Webfinger JRD" do
	user =
	insert(:user,
	ap_id: "https://hyrule.world/users/zelda",
	also_known_as: ["https://mushroom.kingdom/users/toad"]
	)

	response =
	build_conn()
	\|> put_req_header("accept", "application/jrd+json")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	\|> json_response(200)

	assert response["subject"] == "acct:#{user.nickname}@localhost"

	assert response["aliases"] == [
	"https://hyrule.world/users/zelda",
	"https://mushroom.kingdom/users/toad"
	]
	end

	test "reach user on tld, while pleroma is running on subdomain" do
	- Pleroma.Web.Endpoint.config_change(
	- [{Pleroma.Web.Endpoint, url: [host: "sub.example.com"]}],
	- []
	- )
	-
	clear_config([Pleroma.Web.Endpoint, :url, :host], "sub.example.com")

	clear_config([Pleroma.Web.WebFinger, :domain], "example.com")

	user = insert(:user, ap_id: "https://sub.example.com/users/bobby", nickname: "bobby")

	response =
	build_conn()
	\|> put_req_header("accept", "application/jrd+json")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@example.com")
	\|> json_response(200)

	assert response["subject"] == "acct:#{user.nickname}@example.com"
	assert response["aliases"] == ["https://sub.example.com/users/#{user.nickname}"]
	-
	- on_exit(fn ->
	- Pleroma.Web.Endpoint.config_change(
	- [{Pleroma.Web.Endpoint, url: [host: "localhost"]}],
	- []
	- )
	- end)
	end

	test "it returns 404 when user isn't found (JSON)" do
	result =
	build_conn()
	\|> put_req_header("accept", "application/jrd+json")
	\|> get("/.well-known/webfinger?resource=acct:jimm@localhost")
	\|> json_response(404)

	assert result == "Couldn't find user"
	end

	test "Webfinger XML" do
	user =
	insert(:user,
	ap_id: "https://hyrule.world/users/zelda",
	also_known_as: ["https://mushroom.kingdom/users/toad"]
	)

	response =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	\|> response(200)

	assert response =~ "<Alias>https://hyrule.world/users/zelda</Alias>"
	assert response =~ "<Alias>https://mushroom.kingdom/users/toad</Alias>"
	end

	test "it returns 404 when user isn't found (XML)" do
	result =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml")
	\|> get("/.well-known/webfinger?resource=acct:jimm@localhost")
	\|> response(404)

	assert result == "Couldn't find user"
	end

	test "Sends a 404 when invalid format" do
	user = insert(:user)

	assert capture_log(fn ->
	assert_raise Phoenix.NotAcceptableError, fn ->
	build_conn()
	\|> put_req_header("accept", "text/html")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	end
	end) =~ "no supported media type in accept header"
	end

	test "Sends a 400 when resource param is missing" do
	response =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml,application/jrd+json")
	\|> get("/.well-known/webfinger")

	assert response(response, 400)
	end
	end
	diff --git a/test/support/helpers.ex b/test/support/helpers.ex
	index e3bfa73d2..7fa6c31a4 100644
	--- a/test/support/helpers.ex
	+++ b/test/support/helpers.ex
	@@ -1,138 +1,171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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

	require Logger

	+ @doc "Accepts two URLs/URIs and sorts the query parameters before comparing"
	+ def uri_equal?(a, b) do
	+ a_sorted = uri_query_sort(a)
	+ b_sorted = uri_query_sort(b)
	+
	+ match?(^a_sorted, b_sorted)
	+ end
	+
	+ @doc "Accepts a URL/URI and sorts the query parameters"
	+ def uri_query_sort(uri) do
	+ parsed = URI.parse(uri)
	+
	+ sorted_query =
	+ String.split(parsed.query, "&")
	+ \|> Enum.sort()
	+ \|> Enum.join("&")
	+
	+ parsed
	+ \|> Map.put(:query, sorted_query)
	+ \|> URI.to_string()
	+ end
	+
	+ @doc "Returns the value of the specified query parameter for the provided URL"
	+ def get_query_parameter(url, param) do
	+ url
	+ \|> URI.parse()
	+ \|> Map.get(:query)
	+ \|> URI.query_decoder()
	+ \|> Enum.to_list()
	+ \|> Enum.into(%{}, fn {x, y} -> {x, y} end)
	+ \|> Map.get(param)
	+ end
	+
	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
	# NOTE: `clear_config([section, key], value)` != `clear_config([section], key: value)` (!)
	# Displaying a warning to prevent unintentional clearing of all but one keys in section
	if Keyword.keyword?(temp_setting) and length(temp_setting) == 1 do
	Logger.warning(
	"Please change `clear_config([section], key: value)` to `clear_config([section, key], value)`"
	)
	end

	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/test_helper.exs b/test/test_helper.exs
	index 27b777d5f..e65f7c1d1 100644
	--- a/test/test_helper.exs
	+++ b/test/test_helper.exs
	@@ -1,32 +1,38 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	Code.put_compiler_option(:warnings_as_errors, true)

	ExUnit.start(exclude: [:federated, :erratic])

	+if match?({:unix, :darwin}, :os.type()) do
	+ excluded = ExUnit.configuration() \|> Keyword.get(:exclude, [])
	+ excluded = excluded ++ [:skip_darwin]
	+ ExUnit.configure(exclude: excluded)
	+end
	+
	Ecto.Adapters.SQL.Sandbox.mode(Pleroma.Repo, :manual)

	Mox.defmock(Pleroma.ReverseProxy.ClientMock, for: Pleroma.ReverseProxy.Client)
	Mox.defmock(Pleroma.GunMock, for: Pleroma.Gun)

	{:ok, _} = Application.ensure_all_started(:ex_machina)

	ExUnit.after_suite(fn _results ->
	uploads = Pleroma.Config.get([Pleroma.Uploaders.Local, :uploads], "test/uploads")
	File.rm_rf!(uploads)
	end)

	defmodule Pleroma.Test.StaticConfig do
	@moduledoc """
	This module provides a Config that is completely static, built at startup time from the environment. It's safe to use in testing as it will not modify any state.
	"""

	@behaviour Pleroma.Config.Getting
	@config Application.get_all_env(:pleroma)

	def get(path, default \\ nil) do
	get_in(@config, path) \|\| default
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 4:24 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798343
Default Alt Text: (277 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions