No OneTemporary
Actions

Authored By

Unknown

Size

265 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	index 45dcd6091..6b67047f7 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,556 +1,556 @@
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.13.4-otp-25

	variables: &global_variables
	# Only used for the release
	ELIXIR_VER: 1.13.4
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	DB_PORT: "5432"
	MIX_ENV: test

	workflow:
	rules:
	- if: $CI_PIPELINE_SOURCE == "merge_request_event"
	- if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
	when: never
	- if: $CI_COMMIT_BRANCH

	cache: &global_cache_policy
	key:
	files:
	- mix.lock
	paths:
	- deps
	- _build

	stages:
	- build
	- lint
	- test
	- check-changelog
	- benchmark
	- deploy
	- release
	- docker
	- docker-combine

	before_script:
	- echo $MIX_ENV
	- rm -rf _build/*/lib/pleroma
	- mix deps.get

	after_script:
	- rm -rf _build/*/lib/pleroma

	check-changelog:
	stage: check-changelog
	image: alpine
	rules:
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate-extract'
	when: never
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate'
	when: never
	- if: $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop"
	before_script: ''
	after_script: ''
	cache: {}
	script:
	- apk add git
	- sh ./tools/check-changelog

	.build_changes_policy:
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "*/.ex"
	- "*/.exs"
	- "mix.lock"

	.using-ci-base:
	tags:
	- amd64

	build-1.13.4-otp-25:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	script:
	- mix compile --force

	build-1.15.8-otp-26:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.15.8-otp-26
	allow_failure: true
	script:
	- mix compile --force

	spec-build:
	extends:
	- .using-ci-base
	stage: build
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "lib/pleroma/web/api_spec/*/.ex"
	- "lib/pleroma/web/api_spec.ex"
	artifacts:
	paths:
	- spec.json
	script:
	- mix pleroma.openapi_spec spec.json

	benchmark:
	extends:
	- .using-ci-base
	stage: benchmark
	when: manual
	variables:
	MIX_ENV: benchmark
	services:
	- name: postgres:11.22-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.load_testing

	unit-testing-1.13.4-otp-25:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull
	services: &testing_services
	- name: postgres:13-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script: &testing_script
	- mix ecto.create
	- mix ecto.migrate
	- mix test --cover --preload-modules
	coverage: '/^Line total: ([^ ]*%)$/'
	artifacts:
	reports:
	coverage_report:
	coverage_format: cobertura
	path: coverage.xml

	unit-testing-1.15.8-otp-26:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.15.8-otp-26
	allow_failure: true
	cache: *testing_cache_policy
	services: *testing_services
	script: *testing_script

	unit-testing-1.13.4-otp-25-erratic:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	retry: 2
	allow_failure: true
	cache: *testing_cache_policy
	services: *testing_services
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix test --only=erratic

	-formatting-1.13:
	+formatting-1.15:
	extends: .build_changes_policy
	- image: &formatting_elixir elixir:1.13-alpine
	+ image: &formatting_elixir elixir:1.15-alpine
	stage: lint
	cache: *testing_cache_policy
	before_script: &current_bfr_script
	- apk update
	- apk add build-base cmake file-dev git openssl
	- mix local.hex --force
	- mix local.rebar --force
	- mix deps.get
	script:
	- mix format --check-formatted

	cycles-1.13:
	extends: .build_changes_policy
	image: *formatting_elixir
	stage: lint
	cache: {}
	before_script: *current_bfr_script
	script:
	- mix compile
	- mix xref graph --format cycles --label compile \| awk '{print $0} END{exit ($0 != "No cycles found")}'

	analysis:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: lint
	cache: *testing_cache_policy
	script:
	- mix credo --strict --only=warnings,todo,fixme,consistency,readability

	dialyzer:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: lint
	allow_failure: true
	when: manual
	cache: *testing_cache_policy
	tags:
	- feld
	script:
	- mix dialyzer

	docs-deploy:
	stage: deploy
	cache: *testing_cache_policy
	image: alpine:latest
	only:
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	before_script:
	- apk add curl
	script:
	- curl --fail-with-body -X POST -F"token=$CI_JOB_TOKEN" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" https://git.pleroma.social/api/v4/projects/673/trigger/pipeline
	review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	url: https://$CI_ENVIRONMENT_SLUG.pleroma.online/
	on_stop: stop_review_app
	only:
	- branches
	except:
	- master
	- develop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- (ssh -t dokku@pleroma.online -- apps:create "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- git:set "$CI_ENVIRONMENT_SLUG" keep-git-dir true) \|\| true
	- ssh -t dokku@pleroma.online -- config:set "$CI_ENVIRONMENT_SLUG" APP_NAME="$CI_ENVIRONMENT_SLUG" APP_HOST="$CI_ENVIRONMENT_SLUG.pleroma.online" MIX_ENV=dokku
	- (ssh -t dokku@pleroma.online -- postgres:create $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db) \|\| true
	- (ssh -t dokku@pleroma.online -- postgres:link $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- certs:add "$CI_ENVIRONMENT_SLUG" /home/dokku/server.crt /home/dokku/server.key) \|\| true
	- git push -f dokku@pleroma.online:$CI_ENVIRONMENT_SLUG $CI_COMMIT_SHA:refs/heads/master

	spec-deploy:
	stage: deploy
	artifacts:
	paths:
	- spec.json
	only:
	- develop@pleroma/pleroma
	image: alpine:latest
	before_script:
	- apk add curl
	script:
	- curl --fail-with-body -X POST -F"token=$CI_JOB_TOKEN" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" -F"variables[JOB_REF]=$CI_JOB_ID" https://git.pleroma.social/api/v4/projects/1130/trigger/pipeline


	stop_review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	action: stop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- ssh -t dokku@pleroma.online -- --force apps:destroy "$CI_ENVIRONMENT_SLUG"
	- ssh -t dokku@pleroma.online -- --force postgres:destroy $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db

	amd64:
	stage: release
	image: elixir:$ELIXIR_VER
	only: &release-only
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- /^maint/.*$/@pleroma/pleroma
	- /^release/.*$/@pleroma/pleroma
	tags:
	- amd64
	artifacts: &release-artifacts
	name: "pleroma-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA-$CI_JOB_NAME"
	paths:
	- release/*
	# Ideally it would be never for master branch and with the next commit for develop,
	# but Gitlab does not support neither `only` for artifacts
	# nor setting it to never from .gitlab-ci.yml
	# nor expiring with the next commit
	expire_in: 42 yrs

	cache: &release-cache
	key: $CI_COMMIT_REF_NAME-$CI_JOB_NAME
	paths:
	- deps
	variables: &release-variables
	MIX_ENV: prod
	VIX_COMPILATION_MODE: PLATFORM_PROVIDED_LIBVIPS
	before_script: &before-release
	- apt-get update && apt-get install -y cmake libmagic-dev libvips-dev erlang-dev
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: &release
	- mix deps.get --only prod
	- mkdir release
	- export PLEROMA_BUILD_BRANCH=$CI_COMMIT_REF_NAME
	- mix release --path release


	amd64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	image: elixir:$ELIXIR_VER-alpine
	tags:
	- amd64
	cache: *release-cache
	variables: *release-variables
	before_script: &before-release-musl
	- apk add git build-base cmake file-dev openssl vips-dev
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: *release

	arm:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	arm64:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image: arm64v8/elixir:$ELIXIR_VER
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image: arm64v8/elixir:$ELIXIR_VER-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	.kaniko:
	stage: docker
	image:
	name: gcr.io/kaniko-project/executor:debug
	entrypoint: [""]
	cache: {}
	dependencies: []
	before_script: &before-kaniko
	- export CI_JOB_TIMESTAMP=$(date --utc -Iseconds)
	- export CI_VCS_REF=$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest-stable
	- mkdir -p /kaniko/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json

	.kaniko-latest:
	extends: .kaniko
	only:
	- develop@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST

	.kaniko-stable:
	extends: .kaniko
	only:
	- stable@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST_STABLE

	.kaniko-release:
	extends: .kaniko
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko-adhoc:
	extends: .kaniko
	only:
	- /^build-docker/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko:linux/amd64:
	variables:
	BUILD_ARCH: linux/amd64
	BUILD_ARCH_IMG_SUFFIX: linux-amd64
	ELIXIR_IMG: hexpm/elixir
	tags:
	- amd64

	.kaniko:linux/arm64:
	variables:
	BUILD_ARCH: linux/arm64/v8
	BUILD_ARCH_IMG_SUFFIX: linux-arm64-v8
	ELIXIR_IMG: hexpm/elixir
	tags:
	- arm

	.kaniko:linux/arm:
	variables:
	BUILD_ARCH: linux/arm/v7
	BUILD_ARCH_IMG_SUFFIX: linux-arm-v7
	ELIXIR_IMG: git.pleroma.social:5050/pleroma/ci-image/elixir-linux-arm-v7
	tags:
	- arm32-specified

	kaniko-latest:linux/amd64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/amd64

	kaniko-latest:linux/arm64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm64

	kaniko-latest:linux/arm:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm

	kaniko-stable:linux/amd64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/amd64

	kaniko-stable:linux/arm64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm64

	kaniko-stable:linux/arm:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm

	kaniko-release:linux/amd64:
	extends:
	- .kaniko-release
	- .kaniko:linux/amd64

	kaniko-release:linux/arm64:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm64

	kaniko-release:linux/arm:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm

	.docker-combine:
	stage: docker-combine
	image: docker:cli
	cache: {}
	before_script:
	- 'BUILD_ARCHES="linux-amd64 linux-arm64-v8 linux-arm-v7"'
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE:latest-stable
	- 'IMAGES=; for arch in $BUILD_ARCHES; do IMAGES="$IMAGES $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_SHORT_SHA"; done'
	- 'IMAGES_SLUG=; for arch in $BUILD_ARCHES; do IMAGES_SLUG="$IMAGES_SLUG $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_REF_SLUG"; done'
	- 'IMAGES_LATEST=; for arch in $BUILD_ARCHES; do IMAGES_LATEST="$IMAGES_LATEST $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- 'IMAGES_LATEST_STABLE=; for arch in $BUILD_ARCHES; do IMAGES_LATEST_STABLE="$IMAGES_LATEST_STABLE $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- mkdir -p ~/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > ~/.docker/config.json

	docker-combine:latest:
	extends: .docker-combine
	only:
	- develop@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST $IMAGES_LATEST'
	- 'docker manifest push $IMAGE_TAG_LATEST'

	docker-combine:stable:
	extends: .docker-combine
	only:
	- stable@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST_STABLE $IMAGES_LATEST_STABLE'
	- 'docker manifest push $IMAGE_TAG_LATEST_STABLE'

	docker-combine:release:
	extends: .docker-combine
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	diff --git a/lib/mix/tasks/pleroma/database.ex b/lib/mix/tasks/pleroma/database.ex
	index 13ac6536c..b82d1f079 100644
	--- a/lib/mix/tasks/pleroma/database.ex
	+++ b/lib/mix/tasks/pleroma/database.ex
	@@ -1,385 +1,385 @@
	# 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.Database do
	alias Pleroma.Conversation
	alias Pleroma.Maintenance
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	require Logger
	require Pleroma.Constants

	import Ecto.Query
	import Mix.Pleroma

	use Mix.Task

	@shortdoc "A collection of database related tasks"
	@moduledoc File.read!("docs/administration/CLI_tasks/database.md")

	def run(["remove_embedded_objects" \| args]) do
	{options, [], []} =
	OptionParser.parse(
	args,
	strict: [
	vacuum: :boolean
	]
	)

	start_pleroma()
	Logger.info("Removing embedded objects")

	Repo.query!(
	"update activities set data = safe_jsonb_set(data, '{object}'::text[], data->'object'->'id') where data->'object'->>'id' is not null;",
	[],
	timeout: :infinity
	)

	if Keyword.get(options, :vacuum) do
	Maintenance.vacuum("full")
	end
	end

	def run(["bump_all_conversations"]) do
	start_pleroma()
	Conversation.bump_for_all_activities()
	end

	def run(["update_users_following_followers_counts"]) do
	start_pleroma()

	Repo.transaction(
	fn ->
	from(u in User, select: u)
	\|> Repo.stream()
	\|> Stream.each(&User.update_follower_count/1)
	\|> Stream.run()
	end,
	timeout: :infinity
	)
	end

	def run(["prune_objects" \| args]) do
	{options, [], []} =
	OptionParser.parse(
	args,
	strict: [
	vacuum: :boolean,
	keep_threads: :boolean,
	keep_non_public: :boolean,
	prune_orphaned_activities: :boolean
	]
	)

	start_pleroma()

	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days])
	time_deadline = NaiveDateTime.utc_now() \|> NaiveDateTime.add(-(deadline * 86_400))

	log_message = "Pruning objects older than #{deadline} days"

	log_message =
	if Keyword.get(options, :keep_non_public) do
	log_message <> ", keeping non public posts"
	else
	log_message
	end

	log_message =
	if Keyword.get(options, :keep_threads) do
	log_message <> ", keeping threads intact"
	else
	log_message
	end

	log_message =
	if Keyword.get(options, :prune_orphaned_activities) do
	log_message <> ", pruning orphaned activities"
	else
	log_message
	end

	log_message =
	if Keyword.get(options, :vacuum) do
	log_message <>
	", doing a full vacuum (you shouldn't do this as a recurring maintanance task)"
	else
	log_message
	end

	Logger.info(log_message)

	if Keyword.get(options, :keep_threads) do
	# We want to delete objects from threads where
	# 1. the newest post is still old
	# 2. none of the activities is local
	# 3. none of the activities is bookmarked
	# 4. optionally none of the posts is non-public
	deletable_context =
	if Keyword.get(options, :keep_non_public) do
	Pleroma.Activity
	\|> join(:left, [a], b in Pleroma.Bookmark, on: a.id == b.activity_id)
	\|> group_by([a], fragment("? ->> 'context'::text", a.data))
	\|> having(
	[a],
	not fragment(
	# Posts (checked on Create Activity) is non-public
	"bool_or((not(?->'to' \\? ? OR ?->'cc' \\? ?)) and ? ->> 'type' = 'Create')",
	a.data,
	^Pleroma.Constants.as_public(),
	a.data,
	^Pleroma.Constants.as_public(),
	a.data
	)
	)
	else
	Pleroma.Activity
	\|> join(:left, [a], b in Pleroma.Bookmark, on: a.id == b.activity_id)
	\|> group_by([a], fragment("? ->> 'context'::text", a.data))
	end
	\|> having([a], max(a.updated_at) < ^time_deadline)
	\|> having([a], not fragment("bool_or(?)", a.local))
	\|> having([_, b], fragment("max(?::text) is null", b.id))
	\|> select([a], fragment("? ->> 'context'::text", a.data))

	Pleroma.Object
	\|> where([o], fragment("? ->> 'context'::text", o.data) in subquery(deletable_context))
	else
	if Keyword.get(options, :keep_non_public) do
	Pleroma.Object
	\|> where(
	[o],
	fragment(
	"?->'to' \\? ? OR ?->'cc' \\? ?",
	o.data,
	^Pleroma.Constants.as_public(),
	o.data,
	^Pleroma.Constants.as_public()
	)
	)
	else
	Pleroma.Object
	end
	\|> where([o], o.updated_at < ^time_deadline)
	\|> where(
	[o],
	fragment("split_part(?->>'actor', '/', 3) != ?", o.data, ^Pleroma.Web.Endpoint.host())
	)
	end
	\|> Repo.delete_all(timeout: :infinity)

	if !Keyword.get(options, :keep_threads) do
	# Without the --keep-threads option, it's possible that bookmarked
	# objects have been deleted. We remove the corresponding bookmarks.
	"""
	delete from public.bookmarks
	where id in (
	select b.id from public.bookmarks b
	left join public.activities a on b.activity_id = a.id
	left join public.objects o on a."data" ->> 'object' = o.data ->> 'id'
	where o.id is null
	)
	"""
	\|> Repo.query([], timeout: :infinity)
	end

	if Keyword.get(options, :prune_orphaned_activities) do
	# Prune activities who link to a single object
	"""
	delete from public.activities
	where id in (
	select a.id from public.activities a
	left join public.objects o on a.data ->> 'object' = o.data ->> 'id'
	left join public.activities a2 on a.data ->> 'object' = a2.data ->> 'id'
	left join public.users u on a.data ->> 'object' = u.ap_id
	where not a.local
	and jsonb_typeof(a."data" -> 'object') = 'string'
	and o.id is null
	and a2.id is null
	and u.id is null
	)
	"""
	\|> Repo.query([], timeout: :infinity)

	# Prune activities who link to an array of objects
	"""
	delete from public.activities
	where id in (
	select a.id from public.activities a
	join json_array_elements_text((a."data" -> 'object')::json) as j on jsonb_typeof(a."data" -> 'object') = 'array'
	left join public.objects o on j.value = o.data ->> 'id'
	left join public.activities a2 on j.value = a2.data ->> 'id'
	left join public.users u on j.value = u.ap_id
	group by a.id
	having max(o.data ->> 'id') is null
	and max(a2.data ->> 'id') is null
	and max(u.ap_id) is null
	)
	"""
	\|> Repo.query([], timeout: :infinity)
	end

	"""
	DELETE FROM hashtags AS ht
	WHERE NOT EXISTS (
	SELECT 1 FROM hashtags_objects hto
	WHERE ht.id = hto.hashtag_id)
	"""
	\|> Repo.query()

	if Keyword.get(options, :vacuum) do
	Maintenance.vacuum("full")
	end
	end

	def run(["fix_likes_collections"]) do
	start_pleroma()

	from(object in Object,
	where: fragment("(?)->>'likes' is not null", object.data),
	select: %{id: object.id, likes: fragment("(?)->>'likes'", object.data)}
	)
	\|> Pleroma.Repo.chunk_stream(100, :batches)
	\|> Stream.each(fn objects ->
	ids =
	objects
	\|> Enum.filter(fn object -> object.likes \|> Jason.decode!() \|> is_map() end)
	\|> Enum.map(& &1.id)

	Object
	\|> where([object], object.id in ^ids)
	\|> update([object],
	set: [
	data:
	fragment(
	"safe_jsonb_set(?, '{likes}', '[]'::jsonb, true)",
	object.data
	)
	]
	)
	\|> Repo.update_all([], timeout: :infinity)
	end)
	\|> Stream.run()
	end

	def run(["vacuum", args]) do
	start_pleroma()

	Maintenance.vacuum(args)
	end

	def run(["ensure_expiration"]) do
	start_pleroma()
	days = Pleroma.Config.get([:mrf_activity_expiration, :days], 365)

	Pleroma.Activity
	\|> join(:inner, [a], o in Object,
	on:
	fragment(
	"(?->>'id') = associated_object_id((?))",
	o.data,
	a.data
	)
	)
	\|> where(local: true)
	\|> where([a], fragment("(? ->> 'type'::text) = 'Create'", a.data))
	\|> where([_a, o], fragment("?->>'type' = 'Note'", o.data))
	\|> Pleroma.Repo.chunk_stream(100, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity ->
	expires_at =
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: days)

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: expires_at
	})
	end)
	end)
	\|> Stream.run()
	end

	def run(["set_text_search_config", tsconfig]) do
	start_pleroma()
	%{rows: [[tsc]]} = Ecto.Adapters.SQL.query!(Pleroma.Repo, "SHOW default_text_search_config;")
	shell_info("Current default_text_search_config: #{tsc}")

	%{rows: [[db]]} = Ecto.Adapters.SQL.query!(Pleroma.Repo, "SELECT current_database();")
	shell_info("Update default_text_search_config: #{tsconfig}")

	%{messages: msg} =
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"ALTER DATABASE #{db} SET default_text_search_config = '#{tsconfig}';"
	)

	# non-exist config will not raise exception but only give >0 messages
	if length(msg) > 0 do
	shell_info("Error: #{inspect(msg, pretty: true)}")
	else
	rum_enabled = Pleroma.Config.get([:database, :rum_enabled])
	shell_info("Recreate index, RUM: #{rum_enabled}")

	# Note SQL below needs to be kept up-to-date with latest GIN or RUM index definition in future
	if rum_enabled do
	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"CREATE OR REPLACE FUNCTION objects_fts_update() RETURNS trigger AS $$ BEGIN
	new.fts_content := to_tsvector(new.data->>'content');
	RETURN new;
	END
	$$ LANGUAGE plpgsql",
	[],
	timeout: :infinity
	)

	shell_info("Refresh RUM index")
	Ecto.Adapters.SQL.query!(Pleroma.Repo, "UPDATE objects SET updated_at = NOW();")
	else
	Ecto.Adapters.SQL.query!(Pleroma.Repo, "DROP INDEX IF EXISTS objects_fts;")

	Ecto.Adapters.SQL.query!(
	Pleroma.Repo,
	"CREATE INDEX CONCURRENTLY objects_fts ON objects USING gin(to_tsvector('#{tsconfig}', data->>'content')); ",
	[],
	timeout: :infinity
	)
	end

	- shell_info('Done.')
	+ shell_info(~c"Done.")
	end
	end

	# Rolls back a specific migration (leaving subsequent migrations applied).
	# WARNING: imposes a risk of unrecoverable data loss — proceed at your own responsibility.
	# Based on https://stackoverflow.com/a/53825840
	def run(["rollback", version]) do
	prompt = "SEVERE WARNING: this operation may result in unrecoverable data loss. Continue?"

	if shell_prompt(prompt, "n") in ~w(Yn Y y) do
	{_, result, _} =
	Ecto.Migrator.with_repo(Pleroma.Repo, fn repo ->
	version = String.to_integer(version)
	re = ~r/^#{version}_.*\.exs/
	path = Ecto.Migrator.migrations_path(repo)

	with {_, "" <> file} <- {:find, Enum.find(File.ls!(path), &String.match?(&1, re))},
	{_, [{mod, _} \| _]} <- {:compile, Code.compile_file(Path.join(path, file))},
	{_, :ok} <- {:rollback, Ecto.Migrator.down(repo, version, mod)} do
	{:ok, "Reversed migration: #{file}"}
	else
	{:find, _} -> {:error, "No migration found with version prefix: #{version}"}
	{:compile, e} -> {:error, "Problem compiling migration module: #{inspect(e)}"}
	{:rollback, e} -> {:error, "Problem reversing migration: #{inspect(e)}"}
	end
	end)

	shell_info(inspect(result))
	end
	end
	end
	diff --git a/lib/pleroma/emoji/pack.ex b/lib/pleroma/emoji/pack.ex
	index afc341853..785fdb8b2 100644
	--- a/lib/pleroma/emoji/pack.ex
	+++ b/lib/pleroma/emoji/pack.ex
	@@ -1,661 +1,661 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack
	alias Pleroma.Utils

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

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

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

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

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

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

	{:ok, validate_pack(pack)}
	end
	end

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

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

	_, acc ->
	acc
	end)
	end

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

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

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

	{item, updated_pack}
	end)

	Emoji.reload()

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

	_ ->
	{:ok, pack}
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	result
	end

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

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

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

	struct(__MODULE__, pack_attrs)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	defmodule Pleroma.Object.Updater do
	require Pleroma.Constants

	alias Pleroma.Object
	alias Pleroma.Repo

	def update_content_fields(orig_object_data, updated_object) do
	Pleroma.Constants.status_updatable_fields()
	\|> Enum.reduce(
	%{data: orig_object_data, updated: false},
	fn field, %{data: data, updated: updated} ->
	updated =
	updated or
	(field != "updated" and
	Map.get(updated_object, field) != Map.get(orig_object_data, field))

	data =
	if Map.has_key?(updated_object, field) do
	Map.put(data, field, updated_object[field])
	else
	Map.drop(data, [field])
	end

	%{data: data, updated: updated}
	end
	)
	end

	def maybe_history(object) do
	with history <- Map.get(object, "formerRepresentations"),
	true <- is_map(history),
	"OrderedCollection" <- Map.get(history, "type"),
	true <- is_list(Map.get(history, "orderedItems")),
	true <- is_integer(Map.get(history, "totalItems")) do
	history
	else
	_ -> nil
	end
	end

	def history_for(object) do
	with history when not is_nil(history) <- maybe_history(object) do
	history
	else
	_ -> history_skeleton()
	end
	end

	defp history_skeleton do
	%{
	"type" => "OrderedCollection",
	"totalItems" => 0,
	"orderedItems" => []
	}
	end

	def maybe_update_history(
	updated_object,
	orig_object_data,
	opts
	) do
	updated = opts[:updated]
	use_history_in_new_object? = opts[:use_history_in_new_object?]

	if not updated do
	%{updated_object: updated_object, used_history_in_new_object?: false}
	else
	# Put edit history
	# Note that we may have got the edit history by first fetching the object
	{new_history, used_history_in_new_object?} =
	with true <- use_history_in_new_object?,
	updated_history when not is_nil(updated_history) <- maybe_history(opts[:new_data]) do
	{updated_history, true}
	else
	_ ->
	history = history_for(orig_object_data)

	latest_history_item =
	orig_object_data
	\|> Map.drop(["id", "formerRepresentations"])

	updated_history =
	history
	\|> Map.put("orderedItems", [latest_history_item \| history["orderedItems"]])
	\|> Map.put("totalItems", history["totalItems"] + 1)

	{updated_history, false}
	end

	updated_object =
	updated_object
	\|> Map.put("formerRepresentations", new_history)

	%{updated_object: updated_object, used_history_in_new_object?: used_history_in_new_object?}
	end
	end

	defp maybe_update_poll(to_be_updated, updated_object) do
	choice_key = fn
	%{"anyOf" => [_ \| _]} -> "anyOf"
	%{"oneOf" => [_ \| _]} -> "oneOf"
	_ -> nil
	end

	with true <- to_be_updated["type"] == "Question",
	key when not is_nil(key) <- choice_key.(updated_object),
	true <- key == choice_key.(to_be_updated),
	orig_choices <- to_be_updated[key] \|> Enum.map(&Map.drop(&1, ["replies"])),
	new_choices <- updated_object[key] \|> Enum.map(&Map.drop(&1, ["replies"])),
	true <- orig_choices == new_choices do
	# Choices are the same, but counts are different
	to_be_updated
	\|> Map.put(key, updated_object[key])
	else
	# Choices (or vote type) have changed, do not allow this
	_ -> to_be_updated
	end
	end

	# This calculates the data to be sent as the object of an Update.
	# new_data's formerRepresentations is not considered.
	# formerRepresentations is added to the returned data.
	def make_update_object_data(original_data, new_data, date) do
	%{data: updated_data, updated: updated} =
	original_data
	\|> update_content_fields(new_data)

	if not updated do
	updated_data
	else
	%{updated_object: updated_data} =
	updated_data
	- \|> maybe_update_history(original_data, updated: updated, use_history_in_new_object?: false)
	+ \|> maybe_update_history(original_data,
	+ updated: updated,
	+ use_history_in_new_object?: false
	+ )

	updated_data
	\|> Map.put("updated", date)
	end
	end

	# This calculates the data of the new Object from an Update.
	# new_data's formerRepresentations is considered.
	def make_new_object_data_from_update_object(original_data, new_data) do
	update_is_reasonable =
	with {_, updated} when not is_nil(updated) <- {:cur_updated, new_data["updated"]},
	{_, {:ok, updated_time, _}} <- {:cur_updated, DateTime.from_iso8601(updated)},
	{_, last_updated} when not is_nil(last_updated) <-
	{:last_updated, original_data["updated"] \|\| original_data["published"]},
	{_, {:ok, last_updated_time, _}} <-
	{:last_updated, DateTime.from_iso8601(last_updated)},
	:gt <- DateTime.compare(updated_time, last_updated_time) do
	:update_everything
	else
	# only allow poll updates
	{:cur_updated, _} -> :no_content_update
	:eq -> :no_content_update
	# allow all updates
	{:last_updated, _} -> :update_everything
	# allow no updates
	_ -> false
	end

	%{
	updated_object: updated_data,
	used_history_in_new_object?: used_history_in_new_object?,
	updated: updated
	} =
	if update_is_reasonable == :update_everything do
	%{data: updated_data, updated: updated} =
	original_data
	\|> update_content_fields(new_data)

	updated_data
	\|> maybe_update_history(original_data,
	updated: updated,
	use_history_in_new_object?: true,
	new_data: new_data
	)
	\|> Map.put(:updated, updated)
	else
	%{
	updated_object: original_data,
	used_history_in_new_object?: false,
	updated: false
	}
	end

	updated_data =
	if update_is_reasonable != false do
	updated_data
	\|> maybe_update_poll(new_data)
	else
	updated_data
	end

	%{
	updated_data: updated_data,
	updated: updated,
	used_history_in_new_object?: used_history_in_new_object?
	}
	end

	def for_each_history_item(%{"orderedItems" => items} = history, _object, fun) do
	new_items =
	Enum.map(items, fun)
	\|> Enum.reduce_while(
	{:ok, []},
	fn
	{:ok, item}, {:ok, acc} -> {:cont, {:ok, acc ++ [item]}}
	e, _acc -> {:halt, e}
	end
	)

	case new_items do
	{:ok, items} -> {:ok, Map.put(history, "orderedItems", items)}
	e -> e
	end
	end

	def for_each_history_item(history, _, _) do
	{:ok, history}
	end

	def do_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end

	defp maybe_touch_changeset(changeset, true) do
	updated_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)

	Ecto.Changeset.put_change(changeset, :updated_at, updated_at)
	end

	defp maybe_touch_changeset(changeset, _), do: changeset

	def do_update_and_invalidate_cache(orig_object, updated_object, touch_changeset? \\ false) do
	orig_object_ap_id = updated_object["id"]
	orig_object_data = orig_object.data

	%{
	updated_data: updated_object_data,
	updated: updated,
	used_history_in_new_object?: used_history_in_new_object?
	} = make_new_object_data_from_update_object(orig_object_data, updated_object)

	changeset =
	orig_object
	\|> Repo.preload(:hashtags)
	\|> Object.change(%{data: updated_object_data})
	\|> maybe_touch_changeset(touch_changeset?)

	with {:ok, new_object} <- Repo.update(changeset),
	{:ok, _} <- Object.invalid_object_cache(new_object),
	{:ok, _} <- Object.set_cache(new_object),
	# The metadata/utils.ex uses the object id for the cache.
	{:ok, _} <- Pleroma.Activity.HTML.invalidate_cache_for(new_object.id) do
	if used_history_in_new_object? do
	with create_activity when not is_nil(create_activity) <-
	Pleroma.Activity.get_create_by_object_ap_id(orig_object_ap_id),
	{:ok, _} <- Pleroma.Activity.HTML.invalidate_cache_for(create_activity.id) do
	nil
	else
	_ -> nil
	end
	end

	{:ok, new_object, updated}
	end
	end
	end
	diff --git a/lib/pleroma/user/backup.ex b/lib/pleroma/user/backup.ex
	index 65e0baccd..1821de667 100644
	--- a/lib/pleroma/user/backup.ex
	+++ b/lib/pleroma/user/backup.ex
	@@ -1,413 +1,413 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Backup do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Pleroma.Web.Gettext

	require Logger
	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.User.Backup.State
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Workers.BackupWorker

	@type t :: %__MODULE__{}

	schema "backups" do
	field(:content_type, :string)
	field(:file_name, :string)
	field(:file_size, :integer, default: 0)
	field(:processed, :boolean, default: false)
	field(:state, State, default: :invalid)
	field(:processed_number, :integer, default: 0)

	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

	@config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	def create(user, admin_id \\ nil) do
	with :ok <- validate_limit(user, admin_id),
	{:ok, backup} <- user \|> new() \|> Repo.insert() do
	BackupWorker.process(backup, admin_id)
	end
	end

	def new(user) do
	rand_str = :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false)
	datetime = Calendar.NaiveDateTime.Format.iso8601_basic(NaiveDateTime.utc_now())
	name = "archive-#{user.nickname}-#{datetime}-#{rand_str}.zip"

	%__MODULE__{
	user_id: user.id,
	content_type: "application/zip",
	file_name: name,
	state: :pending
	}
	end

	def delete(backup) do
	uploader = Pleroma.Config.get([Pleroma.Upload, :uploader])

	with :ok <- uploader.delete_file(Path.join("backups", backup.file_name)) do
	Repo.delete(backup)
	end
	end

	defp validate_limit(_user, admin_id) when is_binary(admin_id), do: :ok

	defp validate_limit(user, nil) do
	case get_last(user.id) do
	%__MODULE__{inserted_at: inserted_at} ->
	days = Pleroma.Config.get([__MODULE__, :limit_days])
	diff = Timex.diff(NaiveDateTime.utc_now(), inserted_at, :days)

	if diff > days do
	:ok
	else
	{:error,
	dngettext(
	"errors",
	"Last export was less than a day ago",
	"Last export was less than %{days} days ago",
	days,
	days: days
	)}
	end

	nil ->
	:ok
	end
	end

	def get_last(user_id) do
	__MODULE__
	\|> where(user_id: ^user_id)
	\|> order_by(desc: :id)
	\|> limit(1)
	\|> Repo.one()
	end

	def list(%User{id: user_id}) do
	__MODULE__
	\|> where(user_id: ^user_id)
	\|> order_by(desc: :id)
	\|> Repo.all()
	end

	def remove_outdated(%__MODULE__{id: latest_id, user_id: user_id}) do
	__MODULE__
	\|> where(user_id: ^user_id)
	\|> where([b], b.id != ^latest_id)
	\|> Repo.all()
	\|> Enum.each(&BackupWorker.delete/1)
	end

	def get(id), do: Repo.get(__MODULE__, id)

	defp set_state(backup, state, processed_number \\ nil) do
	struct =
	%{state: state}
	\|> Pleroma.Maps.put_if_present(:processed_number, processed_number)

	backup
	\|> cast(struct, [:state, :processed_number])
	\|> Repo.update()
	end

	def process(
	%__MODULE__{} = backup,
	processor_module \\ __MODULE__.Processor
	) do
	set_state(backup, :running, 0)

	current_pid = self()

	task =
	Task.Supervisor.async_nolink(
	Pleroma.TaskSupervisor,
	processor_module,
	:do_process,
	[backup, current_pid]
	)

	wait_backup(backup, backup.processed_number, task)
	end

	defp wait_backup(backup, current_processed, task) do
	wait_time = @config_impl.get([__MODULE__, :process_wait_time])

	receive do
	{:progress, new_processed} ->
	total_processed = current_processed + new_processed

	set_state(backup, :running, total_processed)
	wait_backup(backup, total_processed, task)

	{:DOWN, _ref, _proc, _pid, reason} ->
	backup = get(backup.id)

	if reason != :normal do
	Logger.error("Backup #{backup.id} process ended abnormally: #{inspect(reason)}")

	{:ok, backup} = set_state(backup, :failed)

	cleanup(backup)

	{:error,
	%{
	backup: backup,
	reason: :exit,
	details: reason
	}}
	else
	{:ok, backup}
	end
	after
	wait_time ->
	Logger.error(
	"Backup #{backup.id} timed out after no response for #{wait_time}ms, terminating"
	)

	Task.Supervisor.terminate_child(Pleroma.TaskSupervisor, task.pid)

	{:ok, backup} = set_state(backup, :failed)

	cleanup(backup)

	{:error,
	%{
	backup: backup,
	reason: :timeout
	}}
	end
	end

	@files [
	- 'actor.json',
	- 'outbox.json',
	- 'likes.json',
	- 'bookmarks.json',
	- 'followers.json',
	- 'following.json'
	+ ~c"actor.json",
	+ ~c"outbox.json",
	+ ~c"likes.json",
	+ ~c"bookmarks.json",
	+ ~c"followers.json",
	+ ~c"following.json"
	]
	@spec export(Pleroma.User.Backup.t(), pid()) :: {:ok, String.t()} \| :error
	def export(%__MODULE__{} = backup, caller_pid) do
	backup = Repo.preload(backup, :user)
	dir = backup_tempdir(backup)

	with :ok <- File.mkdir(dir),
	:ok <- actor(dir, backup.user, caller_pid),
	:ok <- statuses(dir, backup.user, caller_pid),
	:ok <- likes(dir, backup.user, caller_pid),
	:ok <- bookmarks(dir, backup.user, caller_pid),
	:ok <- followers(dir, backup.user, caller_pid),
	:ok <- following(dir, backup.user, caller_pid),
	{:ok, zip_path} <- :zip.create(backup.file_name, @files, cwd: dir),
	{:ok, _} <- File.rm_rf(dir) do
	{:ok, zip_path}
	else
	_ -> :error
	end
	end

	def dir(name) do
	dir = Pleroma.Config.get([__MODULE__, :dir]) \|\| System.tmp_dir!()
	Path.join(dir, name)
	end

	def upload(%__MODULE__{} = backup, zip_path) do
	uploader = Pleroma.Config.get([Pleroma.Upload, :uploader])

	upload = %Pleroma.Upload{
	name: backup.file_name,
	tempfile: zip_path,
	content_type: backup.content_type,
	path: Path.join("backups", backup.file_name)
	}

	with {:ok, _} <- Pleroma.Uploaders.Uploader.put_file(uploader, upload),
	:ok <- File.rm(zip_path) do
	{:ok, upload}
	end
	end

	defp actor(dir, user, caller_pid) do
	with {:ok, json} <-
	UserView.render("user.json", %{user: user})
	\|> Map.merge(%{"likes" => "likes.json", "bookmarks" => "bookmarks.json"})
	\|> Jason.encode() do
	send(caller_pid, {:progress, 1})
	File.write(Path.join(dir, "actor.json"), json)
	end
	end

	defp write_header(file, name) do
	IO.write(
	file,
	"""
	{
	"@context": "https://www.w3.org/ns/activitystreams",
	"id": "#{name}.json",
	"type": "OrderedCollection",
	"orderedItems": [

	"""
	)
	end

	defp should_report?(num, chunk_size), do: rem(num, chunk_size) == 0

	defp backup_tempdir(backup) do
	name = String.trim_trailing(backup.file_name, ".zip")
	dir(name)
	end

	defp cleanup(backup) do
	dir = backup_tempdir(backup)
	File.rm_rf(dir)
	end

	defp write(query, dir, name, fun, caller_pid) do
	path = Path.join(dir, "#{name}.json")

	chunk_size = Pleroma.Config.get([__MODULE__, :process_chunk_size])

	with {:ok, file} <- File.open(path, [:write, :utf8]),
	:ok <- write_header(file, name) do
	total =
	query
	\|> Pleroma.Repo.chunk_stream(chunk_size, _returns_as = :one, timeout: :infinity)
	\|> Enum.reduce(0, fn i, acc ->
	with {:ok, data} <-
	(try do
	fun.(i)
	rescue
	e -> {:error, e}
	end),
	{:ok, str} <- Jason.encode(data),
	:ok <- IO.write(file, str <> ",\n") do
	if should_report?(acc + 1, chunk_size) do
	send(caller_pid, {:progress, chunk_size})
	end

	acc + 1
	else
	{:error, e} ->
	Logger.warning(
	"Error processing backup item: #{inspect(e)}\n The item is: #{inspect(i)}"
	)

	acc

	_ ->
	acc
	end
	end)

	send(caller_pid, {:progress, rem(total, chunk_size)})

	with :ok <- :file.pwrite(file, {:eof, -2}, "\n],\n \"totalItems\": #{total}}") do
	File.close(file)
	end
	end
	end

	defp bookmarks(dir, %{id: user_id} = _user, caller_pid) do
	Bookmark
	\|> where(user_id: ^user_id)
	\|> join(:inner, [b], activity in assoc(b, :activity))
	\|> select([b, a], %{id: b.id, object: fragment("(?)->>'object'", a.data)})
	\|> write(dir, "bookmarks", fn a -> {:ok, a.object} end, caller_pid)
	end

	defp likes(dir, user, caller_pid) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> select([like], %{id: like.id, object: fragment("(?)->>'object'", like.data)})
	\|> write(dir, "likes", fn a -> {:ok, a.object} end, caller_pid)
	end

	defp statuses(dir, user, caller_pid) do
	opts =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:actor_id, user.ap_id)

	[
	[Pleroma.Constants.as_public(), user.ap_id],
	User.following(user),
	Pleroma.List.memberships(user)
	]
	\|> Enum.concat()
	\|> ActivityPub.fetch_activities_query(opts)
	\|> write(
	dir,
	"outbox",
	fn a ->
	with {:ok, activity} <- Transmogrifier.prepare_outgoing(a.data) do
	{:ok, Map.delete(activity, "@context")}
	end
	end,
	caller_pid
	)
	end

	defp followers(dir, user, caller_pid) do
	User.get_followers_query(user)
	\|> write(dir, "followers", fn a -> {:ok, a.ap_id} end, caller_pid)
	end

	defp following(dir, user, caller_pid) do
	User.get_friends_query(user)
	\|> write(dir, "following", fn a -> {:ok, a.ap_id} end, caller_pid)
	end
	end

	defmodule Pleroma.User.Backup.ProcessorAPI do
	@callback do_process(%Pleroma.User.Backup{}, pid()) ::
	{:ok, %Pleroma.User.Backup{}} \| {:error, any()}
	end

	defmodule Pleroma.User.Backup.Processor do
	@behaviour Pleroma.User.Backup.ProcessorAPI

	alias Pleroma.Repo
	alias Pleroma.User.Backup

	import Ecto.Changeset

	@impl true
	def do_process(backup, current_pid) do
	with {:ok, zip_file} <- Backup.export(backup, current_pid),
	{:ok, %{size: size}} <- File.stat(zip_file),
	{:ok, _upload} <- Backup.upload(backup, zip_file) do
	backup
	\|> cast(
	%{
	file_size: size,
	processed: true,
	state: :complete
	},
	[:file_size, :processed, :state]
	)
	\|> Repo.update()
	else
	e -> {:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/search_operation.ex b/lib/pleroma/web/api_spec/operations/search_operation.ex
	index 539743ba3..c2afe8e18 100644
	--- a/lib/pleroma/web/api_spec/operations/search_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/search_operation.ex
	@@ -1,208 +1,210 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.SearchOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.AccountOperation
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.Tag

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	# Note: `with_relationships` param is not supported (PleromaFE uses this op for autocomplete)
	def account_search_operation do
	%Operation{
	tags: ["Search"],
	summary: "Search for matching accounts by username or display name",
	operationId: "SearchController.account_search",
	parameters: [
	Operation.parameter(:q, :query, %Schema{type: :string}, "What to search for",
	required: true
	),
	Operation.parameter(
	:limit,
	:query,
	%Schema{type: :integer, default: 40},
	"Maximum number of results"
	),
	Operation.parameter(
	:resolve,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Attempt WebFinger lookup. Use this when `q` is an exact address."
	),
	Operation.parameter(
	:following,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Only include accounts that the user is following"
	)
	],
	responses: %{
	200 =>
	Operation.response(
	"Array of Account",
	"application/json",
	AccountOperation.array_of_accounts()
	)
	}
	}
	end

	def search_operation do
	%Operation{
	tags: ["Search"],
	summary: "Search results",
	security: [%{"oAuth" => ["read:search"]}],
	operationId: "SearchController.search",
	deprecated: true,
	parameters: [
	Operation.parameter(
	:account_id,
	:query,
	FlakeID.schema(),
	"If provided, statuses returned will be authored only by this account"
	),
	Operation.parameter(
	:type,
	:query,
	%Schema{type: :string, enum: ["accounts", "hashtags", "statuses"]},
	"Search type"
	),
	- Operation.parameter(:q, :query, %Schema{type: :string}, "The search query", required: true),
	+ Operation.parameter(:q, :query, %Schema{type: :string}, "The search query",
	+ required: true
	+ ),
	Operation.parameter(
	:resolve,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Attempt WebFinger lookup"
	),
	Operation.parameter(
	:following,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Only include accounts that the user is following"
	),
	Operation.parameter(
	:offset,
	:query,
	%Schema{type: :integer},
	"Offset"
	),
	with_relationships_param() \| pagination_params()
	],
	responses: %{
	200 => Operation.response("Results", "application/json", results())
	}
	}
	end

	def search2_operation do
	%Operation{
	tags: ["Search"],
	summary: "Search results",
	security: [%{"oAuth" => ["read:search"]}],
	operationId: "SearchController.search2",
	parameters: [
	Operation.parameter(
	:account_id,
	:query,
	FlakeID.schema(),
	"If provided, statuses returned will be authored only by this account"
	),
	Operation.parameter(
	:type,
	:query,
	%Schema{type: :string, enum: ["accounts", "hashtags", "statuses"]},
	"Search type"
	),
	Operation.parameter(:q, :query, %Schema{type: :string}, "What to search for",
	required: true
	),
	Operation.parameter(
	:resolve,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Attempt WebFinger lookup"
	),
	Operation.parameter(
	:following,
	:query,
	%Schema{allOf: [BooleanLike], default: false},
	"Only include accounts that the user is following"
	),
	with_relationships_param() \| pagination_params()
	],
	responses: %{
	200 => Operation.response("Results", "application/json", results2())
	}
	}
	end

	defp results2 do
	%Schema{
	title: "SearchResults",
	type: :object,
	properties: %{
	accounts: %Schema{
	type: :array,
	items: Account,
	description: "Accounts which match the given query"
	},
	statuses: %Schema{
	type: :array,
	items: Status,
	description: "Statuses which match the given query"
	},
	hashtags: %Schema{
	type: :array,
	items: Tag,
	description: "Hashtags which match the given query"
	}
	},
	example: %{
	"accounts" => [Account.schema().example],
	"statuses" => [Status.schema().example],
	"hashtags" => [Tag.schema().example]
	}
	}
	end

	defp results do
	%Schema{
	title: "SearchResults",
	type: :object,
	properties: %{
	accounts: %Schema{
	type: :array,
	items: Account,
	description: "Accounts which match the given query"
	},
	statuses: %Schema{
	type: :array,
	items: Status,
	description: "Statuses which match the given query"
	},
	hashtags: %Schema{
	type: :array,
	items: %Schema{type: :string},
	description: "Hashtags which match the given query"
	}
	},
	example: %{
	"accounts" => [Account.schema().example],
	"statuses" => [Status.schema().example],
	"hashtags" => ["cofe"]
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index e8cd4491c..17ffd820d 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,129 +1,129 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.User

	require Logger

	import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1, fetch_user: 1]

	@behaviour Pleroma.Web.Auth.Authenticator
	@base Pleroma.Web.Auth.PleromaAuthenticator

	@connection_timeout 10_000
	@search_timeout 10_000

	defdelegate get_registration(conn), to: @base
	defdelegate create_from_registration(conn, registration), to: @base
	defdelegate handle_error(conn, error), to: @base
	defdelegate auth_template, to: @base
	defdelegate oauth_consumer_template, to: @base

	def get_user(%Plug.Conn{} = conn) do
	with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
	{:ok, {name, password}} <- fetch_credentials(conn),
	%User{} = user <- ldap_user(name, password) do
	{:ok, user}
	else
	{:ldap, _} ->
	@base.get_user(conn)

	error ->
	error
	end
	end

	defp ldap_user(name, password) do
	ldap = Pleroma.Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	sslopts = Keyword.get(ldap, :sslopts, [])

	options =
	[{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}] ++
	if sslopts != [], do: [{:sslopts, sslopts}], else: []

	case :eldap.open([to_charlist(host)], options) do
	{:ok, connection} ->
	try do
	if Keyword.get(ldap, :tls, false) do
	:application.ensure_all_started(:ssl)

	case :eldap.start_tls(
	connection,
	Keyword.get(ldap, :tlsopts, []),
	@connection_timeout
	) do
	:ok ->
	:ok

	error ->
	Logger.error("Could not start TLS: #{inspect(error)}")
	end
	end

	bind_user(connection, ldap, name, password)
	after
	:eldap.close(connection)
	end

	{:error, error} ->
	Logger.error("Could not open LDAP connection: #{inspect(error)}")
	{:error, {:ldap_connection_error, error}}
	end
	end

	defp bind_user(connection, ldap, name, password) do
	uid = Keyword.get(ldap, :uid, "cn")
	base = Keyword.get(ldap, :base)

	case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
	:ok ->
	case fetch_user(name) do
	%User{} = user ->
	user

	_ ->
	register_user(connection, base, uid, name)
	end

	error ->
	error
	end
	end

	defp register_user(connection, base, uid, name) do
	case :eldap.search(connection, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:timeout, @search_timeout}
	]) do
	{:ok, {:eldap_search_result, [{:eldap_entry, _, attributes}], _}} ->
	params = %{
	name: name,
	nickname: name,
	password: nil
	}

	params =
	- case List.keyfind(attributes, 'mail', 0) do
	+ case List.keyfind(attributes, ~c"mail", 0) do
	{_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
	_ -> params
	end

	changeset = User.register_changeset_ldap(%User{}, params)

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

	error ->
	error
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/websocket_handler.ex b/lib/pleroma/web/mastodon_api/websocket_handler.ex
	index bb27d806d..730295a4c 100644
	--- a/lib/pleroma/web/mastodon_api/websocket_handler.ex
	+++ b/lib/pleroma/web/mastodon_api/websocket_handler.ex
	@@ -1,247 +1,247 @@
	# 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.WebsocketHandler do
	require Logger

	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.StreamerView

	@behaviour Phoenix.Socket.Transport

	# Client ping period.
	@tick :timer.seconds(30)

	@impl Phoenix.Socket.Transport
	def child_spec(_opts), do: :ignore

	# This only prepares the connection and is not in the process yet
	@impl Phoenix.Socket.Transport
	def connect(%{params: params} = transport_info) do
	with access_token <- Map.get(params, "access_token"),
	{:ok, user, oauth_token} <- authenticate_request(access_token),
	{:ok, topic} <-
	Streamer.get_topic(params["stream"], user, oauth_token, params) do
	topics =
	if topic do
	[topic]
	else
	[]
	end

	state = %{
	user: user,
	topics: topics,
	oauth_token: oauth_token,
	count: 0,
	timer: nil
	}

	{:ok, state}
	else
	{:error, :bad_topic} ->
	Logger.debug("#{__MODULE__} bad topic #{inspect(transport_info)}")

	{:error, :bad_topic}

	{:error, :unauthorized} ->
	Logger.debug("#{__MODULE__} authentication error: #{inspect(transport_info)}")
	{:error, :unauthorized}
	end
	end

	# All subscriptions/links and messages cannot be created
	# until the processed is launched with init/1
	@impl Phoenix.Socket.Transport
	def init(state) do
	Enum.each(state.topics, fn topic -> Streamer.add_socket(topic, state.oauth_token) end)

	Process.send_after(self(), :ping, @tick)

	{:ok, state}
	end

	@impl Phoenix.Socket.Transport
	def handle_in({text, [opcode: :text]}, state) do
	with {:ok, %{} = event} <- Jason.decode(text) do
	handle_client_event(event, state)
	else
	_ ->
	Logger.error("#{__MODULE__} received non-JSON event: #{inspect(text)}")
	{:ok, state}
	end
	end

	def handle_in(frame, state) do
	Logger.error("#{__MODULE__} received frame: #{inspect(frame)}")
	{:ok, state}
	end

	@impl Phoenix.Socket.Transport
	def handle_info({:render_with_user, view, template, item, topic}, state) do
	user = %User{} = User.get_cached_by_ap_id(state.user.ap_id)

	unless Streamer.filtered_by_user?(user, item) do
	message = view.render(template, item, user, topic)
	{:push, {:text, message}, %{state \| user: user}}
	else
	{:ok, state}
	end
	end

	def handle_info({:text, text}, state) do
	{:push, {:text, text}, state}
	end

	def handle_info(:ping, state) do
	Process.send_after(self(), :ping, @tick)

	{:push, {:ping, ""}, state}
	end

	def handle_info(:close, state) do
	- {:stop, {:closed, 'connection closed by server'}, state}
	+ {:stop, {:closed, ~c"connection closed by server"}, state}
	end

	def handle_info(msg, state) do
	Logger.debug("#{__MODULE__} received info: #{inspect(msg)}")

	{:ok, state}
	end

	@impl Phoenix.Socket.Transport
	def terminate(reason, state) do
	Logger.debug(
	"#{__MODULE__} terminating websocket connection for user #{(state.user \|\| %{id: "anonymous"}).id}, topics #{state.topics \|\| "?"}: #{inspect(reason)})"
	)

	Enum.each(state.topics, fn topic -> Streamer.remove_socket(topic) end)
	:ok
	end

	# Public streams without authentication.
	defp authenticate_request(nil) do
	{:ok, nil, nil}
	end

	# Authenticated streams.
	defp authenticate_request(access_token) do
	with oauth_token = %Token{user_id: user_id} <- Repo.get_by(Token, token: access_token),
	user = %User{} <- User.get_cached_by_id(user_id) do
	{:ok, user, oauth_token}
	else
	_ -> {:error, :unauthorized}
	end
	end

	defp handle_client_event(%{"type" => "subscribe", "stream" => _topic} = params, state) do
	with {_, {:ok, topic}} <-
	{:topic, Streamer.get_topic(params["stream"], state.user, state.oauth_token, params)},
	{_, false} <- {:subscribed, topic in state.topics} do
	Streamer.add_socket(topic, state.oauth_token)

	message =
	StreamerView.render("pleroma_respond.json", %{type: "subscribe", result: "success"})

	{:reply, :ok, {:text, message}, %{state \| topics: [topic \| state.topics]}}
	else
	{:subscribed, true} ->
	message =
	StreamerView.render("pleroma_respond.json", %{type: "subscribe", result: "ignored"})

	{:reply, :error, {:text, message}, state}

	{:topic, {:error, error}} ->
	message =
	StreamerView.render("pleroma_respond.json", %{
	type: "subscribe",
	result: "error",
	error: error
	})

	{:reply, :error, {:text, message}, state}
	end
	end

	defp handle_client_event(%{"type" => "unsubscribe", "stream" => _topic} = params, state) do
	with {_, {:ok, topic}} <-
	{:topic, Streamer.get_topic(params["stream"], state.user, state.oauth_token, params)},
	{_, true} <- {:subscribed, topic in state.topics} do
	Streamer.remove_socket(topic)

	message =
	StreamerView.render("pleroma_respond.json", %{type: "unsubscribe", result: "success"})

	{:reply, :ok, {:text, message}, %{state \| topics: List.delete(state.topics, topic)}}
	else
	{:subscribed, false} ->
	message =
	StreamerView.render("pleroma_respond.json", %{type: "unsubscribe", result: "ignored"})

	{:reply, :error, {:text, message}, state}

	{:topic, {:error, error}} ->
	message =
	StreamerView.render("pleroma_respond.json", %{
	type: "unsubscribe",
	result: "error",
	error: error
	})

	{:reply, :error, {:text, message}, state}
	end
	end

	defp handle_client_event(
	%{"type" => "pleroma:authenticate", "token" => access_token} = _params,
	state
	) do
	with {:auth, nil, nil} <- {:auth, state.user, state.oauth_token},
	{:ok, user, oauth_token} <- authenticate_request(access_token) do
	message =
	StreamerView.render("pleroma_respond.json", %{
	type: "pleroma:authenticate",
	result: "success"
	})

	{:reply, :ok, {:text, message}, %{state \| user: user, oauth_token: oauth_token}}
	else
	{:auth, _, _} ->
	message =
	StreamerView.render("pleroma_respond.json", %{
	type: "pleroma:authenticate",
	result: "error",
	error: :already_authenticated
	})

	{:reply, :error, {:text, message}, state}

	_ ->
	message =
	StreamerView.render("pleroma_respond.json", %{
	type: "pleroma:authenticate",
	result: "error",
	error: :unauthorized
	})

	{:reply, :error, {:text, message}, state}
	end
	end

	defp handle_client_event(params, state) do
	Logger.error("#{__MODULE__} received unknown event: #{inspect(params)}")
	{:ok, state}
	end

	def handle_error(conn, :unauthorized) do
	Plug.Conn.send_resp(conn, 401, "Unauthorized")
	end

	def handle_error(conn, _reason) do
	Plug.Conn.send_resp(conn, 404, "Not Found")
	end
	end
	diff --git a/lib/pleroma/web/plugs/o_auth_scopes_plug.ex b/lib/pleroma/web/plugs/o_auth_scopes_plug.ex
	index faf0fd8c6..08c2f61ea 100644
	--- a/lib/pleroma/web/plugs/o_auth_scopes_plug.ex
	+++ b/lib/pleroma/web/plugs/o_auth_scopes_plug.ex
	@@ -1,58 +1,60 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.OAuthScopesPlug do
	import Plug.Conn
	import Pleroma.Web.Gettext

	alias Pleroma.Helpers.AuthHelper

	use Pleroma.Web, :plug

	def init(%{scopes: _} = options), do: options

	@impl true
	def perform(%Plug.Conn{assigns: assigns} = conn, %{scopes: scopes} = options) do
	op = options[:op] \|\| :\|
	token = assigns[:token]

	matched_scopes = (token && filter_descendants(scopes, token.scopes)) \|\| []

	cond do
	token && op == :\| && Enum.any?(matched_scopes) ->
	conn

	token && op == :& && matched_scopes == scopes ->
	conn

	options[:fallback] == :proceed_unauthenticated ->
	AuthHelper.drop_auth_info(conn)

	true ->
	missing_scopes = scopes -- matched_scopes
	permissions = Enum.join(missing_scopes, " #{op} ")

	error_message =
	- dgettext("errors", "Insufficient permissions: %{permissions}.", permissions: permissions)
	+ dgettext("errors", "Insufficient permissions: %{permissions}.",
	+ permissions: permissions
	+ )

	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:forbidden, Jason.encode!(%{error: error_message}))
	\|> halt()
	end
	end

	@doc "Keeps those of `scopes` which are descendants of `supported_scopes`"
	def filter_descendants(scopes, supported_scopes) do
	Enum.filter(
	scopes,
	fn scope ->
	Enum.find(
	supported_scopes,
	&(scope == &1 \|\| String.starts_with?(scope, &1 <> ":"))
	)
	end
	)
	end
	end
	diff --git a/lib/pleroma/web/xml.ex b/lib/pleroma/web/xml.ex
	index 64329e4ba..3997e1661 100644
	--- a/lib/pleroma/web/xml.ex
	+++ b/lib/pleroma/web/xml.ex
	@@ -1,48 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.XML do
	require Logger

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

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

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

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

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

	{:ok, doc}
	rescue
	_e ->
	Logger.debug("Couldn't parse XML: #{inspect(text)}")
	:error
	catch
	:exit, _error ->
	Logger.debug("Couldn't parse XML: #{inspect(text)}")
	:error
	end
	end
	end
	diff --git a/priv/repo/migrations/20180516154905_create_user_trigram_index.exs b/priv/repo/migrations/20180516154905_create_user_trigram_index.exs
	index 68878e1e2..049b10175 100644
	--- a/priv/repo/migrations/20180516154905_create_user_trigram_index.exs
	+++ b/priv/repo/migrations/20180516154905_create_user_trigram_index.exs
	@@ -1,13 +1,16 @@
	# 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.CreateUserTrigramIndex do
	use Ecto.Migration

	def change do
	create_if_not_exists(
	- index(:users, ["(nickname \|\| name) gist_trgm_ops"], name: :users_trigram_index, using: :gist)
	+ index(:users, ["(nickname \|\| name) gist_trgm_ops"],
	+ name: :users_trigram_index,
	+ using: :gist
	+ )
	)
	end
	end
	diff --git a/priv/repo/migrations/20190118074940_fix_user_trigram_index.exs b/priv/repo/migrations/20190118074940_fix_user_trigram_index.exs
	index b0f5238a0..3958ea262 100644
	--- a/priv/repo/migrations/20190118074940_fix_user_trigram_index.exs
	+++ b/priv/repo/migrations/20190118074940_fix_user_trigram_index.exs
	@@ -1,26 +1,29 @@
	# 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.FixUserTrigramIndex do
	use Ecto.Migration

	def up do
	drop_if_exists(index(:users, [], name: :users_trigram_index))

	create_if_not_exists(
	index(:users, ["(trim(nickname \|\| ' ' \|\| coalesce(name, ''))) gist_trgm_ops"],
	name: :users_trigram_index,
	using: :gist
	)
	)
	end

	def down do
	drop_if_exists(index(:users, [], name: :users_trigram_index))

	create_if_not_exists(
	- index(:users, ["(nickname \|\| name) gist_trgm_ops"], name: :users_trigram_index, using: :gist)
	+ index(:users, ["(nickname \|\| name) gist_trgm_ops"],
	+ name: :users_trigram_index,
	+ using: :gist
	+ )
	)
	end
	end
	diff --git a/priv/repo/migrations/20190603173419_add_tag_index_to_objects.exs b/priv/repo/migrations/20190603173419_add_tag_index_to_objects.exs
	index 00c71e95f..a3cb17f3b 100644
	--- a/priv/repo/migrations/20190603173419_add_tag_index_to_objects.exs
	+++ b/priv/repo/migrations/20190603173419_add_tag_index_to_objects.exs
	@@ -1,15 +1,18 @@
	# 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.AddTagIndexToObjects do
	use Ecto.Migration

	def change do
	drop_if_exists(
	- index(:activities, ["(data #> '{\"object\",\"tag\"}')"], using: :gin, name: :activities_tags)
	+ index(:activities, ["(data #> '{\"object\",\"tag\"}')"],
	+ using: :gin,
	+ name: :activities_tags
	+ )
	)

	create_if_not_exists(index(:objects, ["(data->'tag')"], using: :gin, name: :objects_tags))
	end
	end
	diff --git a/priv/repo/migrations/20200919182636_remoteip_plug_rename.exs b/priv/repo/migrations/20200919182636_remoteip_plug_rename.exs
	index b9a8fd0e1..69627d3d8 100644
	--- a/priv/repo/migrations/20200919182636_remoteip_plug_rename.exs
	+++ b/priv/repo/migrations/20200919182636_remoteip_plug_rename.exs
	@@ -1,23 +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.Repo.Migrations.RemoteipPlugRename do
	use Ecto.Migration

	import Ecto.Query

	def up do
	config =
	- from(c in Pleroma.ConfigDB, where: c.group == ^:pleroma and c.key == ^Pleroma.Plugs.RemoteIp)
	+ from(c in Pleroma.ConfigDB,
	+ where: c.group == ^:pleroma and c.key == ^Pleroma.Plugs.RemoteIp
	+ )
	\|> Pleroma.Repo.one()

	if config do
	config
	\|> Ecto.Changeset.change(key: Pleroma.Web.Plugs.RemoteIp)
	\|> Pleroma.Repo.update()
	end
	end

	def down, do: :ok
	end
	diff --git a/test/pleroma/config_db_test.exs b/test/pleroma/config_db_test.exs
	index e20da1574..d68e4e6fa 100644
	--- a/test/pleroma/config_db_test.exs
	+++ b/test/pleroma/config_db_test.exs
	@@ -1,543 +1,543 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDBTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.ConfigDB

	test "get_by_params/1" do
	config = insert(:config)
	insert(:config)

	assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	test "get_all_as_keyword/0" do
	saved = insert(:config)
	insert(:config, group: ":goose", key: ":level", value: :info)
	insert(:config, group: ":goose", key: ":meta", value: [:none])

	insert(:config,
	group: ":goose",
	key: ":webhook_url",
	value: "https://gander.com/"
	)

	config = ConfigDB.get_all_as_keyword()

	assert config[:pleroma] == [
	{saved.key, saved.value}
	]

	assert config[:goose][:level] == :info
	assert config[:goose][:meta] == [:none]
	assert config[:goose][:webhook_url] == "https://gander.com/"
	end

	describe "update_or_create/1" do
	test "common" do
	config = insert(:config)
	key2 = :another_key

	params = [
	%{group: :pleroma, key: key2, value: "another_value"},
	%{group: :pleroma, key: config.key, value: [a: 1, b: 2, c: "new_value"]}
	]

	assert Repo.all(ConfigDB) \|> length() == 1

	Enum.each(params, &ConfigDB.update_or_create(&1))

	assert Repo.all(ConfigDB) \|> length() == 2

	config1 = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	config2 = ConfigDB.get_by_params(%{group: :pleroma, key: key2})

	assert config1.value == [a: 1, b: 2, c: "new_value"]
	assert config2.value == "another_value"
	end

	test "partial update" do
	config = insert(:config, value: [key1: "val1", key2: :val2])

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value
	assert updated.value[:key1] == :val1
	assert updated.value[:key2] == :val2
	assert updated.value[:key3] == :val3
	end

	test "deep merge" do
	config = insert(:config, value: [key1: "val1", key2: [k1: :v1, k2: "v2"]])

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key2: [k2: :v2, k3: :v3], key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value
	assert updated.value[:key1] == :val1
	assert updated.value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
	assert updated.value[:key3] == :val3
	end

	test "only full update for some keys" do
	config1 = insert(:config, key: :ecto_repos, value: [repo: Pleroma.Repo])

	config2 = insert(:config, group: :cors_plug, key: :max_age, value: 18)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [another_repo: [Pleroma.Repo]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: 777
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert updated1.value == [another_repo: [Pleroma.Repo]]
	assert updated2.value == 777
	end

	test "full update if value is not keyword" do
	config =
	insert(:config,
	group: ":tesla",
	key: ":adapter",
	value: Tesla.Adapter.Hackney
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: Tesla.Adapter.Httpc
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert updated.value == Tesla.Adapter.Httpc
	end

	test "only full update for some subkeys" do
	config1 =
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	config2 =
	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [groups: [c: 3, d: 4], key: [b: 2]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: [mascots: [c: 3, d: 4], key: [b: 2]]
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	assert updated1.value == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
	assert updated2.value == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
	end
	end

	describe "delete/1" do
	test "error on deleting non existing setting" do
	{:error, error} = ConfigDB.delete(%{group: ":pleroma", key: ":key"})
	assert error =~ "Config with params %{group: \":pleroma\", key: \":key\"} not found"
	end

	test "full delete" do
	config = insert(:config)
	{:ok, deleted} = ConfigDB.delete(%{group: config.group, key: config.key})
	assert Ecto.get_meta(deleted, :state) == :deleted
	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	test "partial subkeys delete" do
	config = insert(:config, value: [groups: [a: 1, b: 2], key: [a: 1]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :loaded

	assert deleted.value == [key: [a: 1]]

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert updated.value == deleted.value
	end

	test "full delete if remaining value after subkeys deletion is empty list" do
	config = insert(:config, value: [groups: [a: 1, b: 2]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :deleted

	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end
	end

	describe "to_elixir_types/1" do
	test "string" do
	assert ConfigDB.to_elixir_types("value as string") == "value as string"
	end

	test "boolean" do
	assert ConfigDB.to_elixir_types(false) == false
	end

	test "nil" do
	assert ConfigDB.to_elixir_types(nil) == nil
	end

	test "integer" do
	assert ConfigDB.to_elixir_types(150) == 150
	end

	test "atom" do
	assert ConfigDB.to_elixir_types(":atom") == :atom
	end

	test "ssl options" do
	assert ConfigDB.to_elixir_types([":tlsv1", ":tlsv1.1", ":tlsv1.2", ":tlsv1.3"]) == [
	:tlsv1,
	:"tlsv1.1",
	:"tlsv1.2",
	:"tlsv1.3"
	]
	end

	test "pleroma module" do
	assert ConfigDB.to_elixir_types("Pleroma.Bookmark") == Pleroma.Bookmark
	end

	test "pleroma string" do
	assert ConfigDB.to_elixir_types("Pleroma") == "Pleroma"
	end

	test "phoenix module" do
	assert ConfigDB.to_elixir_types("Phoenix.Socket.V1.JSONSerializer") ==
	Phoenix.Socket.V1.JSONSerializer
	end

	test "tesla module" do
	assert ConfigDB.to_elixir_types("Tesla.Adapter.Hackney") == Tesla.Adapter.Hackney
	end

	test "ExSyslogger module" do
	assert ConfigDB.to_elixir_types("ExSyslogger") == ExSyslogger
	end

	test "Swoosh.Adapters modules" do
	assert ConfigDB.to_elixir_types("Swoosh.Adapters.SMTP") == Swoosh.Adapters.SMTP
	assert ConfigDB.to_elixir_types("Swoosh.Adapters.AmazonSES") == Swoosh.Adapters.AmazonSES
	end

	test "sigil" do
	assert ConfigDB.to_elixir_types("~r[comp[lL][aA][iI][nN]er]") == ~r/comp[lL][aA][iI][nN]er/
	end

	test "link sigil" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/") == ~r/https:\/\/example.com/
	end

	test "link sigil with um modifiers" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/um") ==
	~r/https:\/\/example.com/um
	end

	test "link sigil with i modifier" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/i") == ~r/https:\/\/example.com/i
	end

	test "link sigil with s modifier" do
	assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/s") == ~r/https:\/\/example.com/s
	end

	test "raise if valid delimiter not found" do
	assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
	ConfigDB.to_elixir_types("~r/https://[]{}<>\"'()\|example.com/s")
	end
	end

	test "2 child tuple" do
	assert ConfigDB.to_elixir_types(%{"tuple" => ["v1", ":v2"]}) == {"v1", :v2}
	end

	test "proxy tuple with localhost" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
	}) == {:proxy_url, {:socks5, :localhost, 1234}}
	end

	test "proxy tuple with domain" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
	- }) == {:proxy_url, {:socks5, 'domain.com', 1234}}
	+ }) == {:proxy_url, {:socks5, ~c"domain.com", 1234}}
	end

	test "proxy tuple with ip" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
	}) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
	end

	test "tuple with n children" do
	assert ConfigDB.to_elixir_types(%{
	"tuple" => [
	"v1",
	":v2",
	"Pleroma.Bookmark",
	150,
	false,
	"Phoenix.Socket.V1.JSONSerializer"
	]
	}) == {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	end

	test "map with string key" do
	assert ConfigDB.to_elixir_types(%{"key" => "value"}) == %{"key" => "value"}
	end

	test "map with atom key" do
	assert ConfigDB.to_elixir_types(%{":key" => "value"}) == %{key: "value"}
	end

	test "list of strings" do
	assert ConfigDB.to_elixir_types(["v1", "v2", "v3"]) == ["v1", "v2", "v3"]
	end

	test "list of modules" do
	assert ConfigDB.to_elixir_types(["Pleroma.Repo", "Pleroma.Activity"]) == [
	Pleroma.Repo,
	Pleroma.Activity
	]
	end

	test "list of atoms" do
	assert ConfigDB.to_elixir_types([":v1", ":v2", ":v3"]) == [:v1, :v2, :v3]
	end

	test "list of mixed values" do
	assert ConfigDB.to_elixir_types([
	"v1",
	":v2",
	"Pleroma.Repo",
	"Phoenix.Socket.V1.JSONSerializer",
	15,
	false
	]) == [
	"v1",
	:v2,
	Pleroma.Repo,
	Phoenix.Socket.V1.JSONSerializer,
	15,
	false
	]
	end

	test "simple keyword" do
	assert ConfigDB.to_elixir_types([%{"tuple" => [":key", "value"]}]) == [key: "value"]
	end

	test "keyword" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	%{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	%{"tuple" => [":migration_lock", nil]},
	%{"tuple" => [":key1", 150]},
	%{"tuple" => [":key2", "string"]}
	]) == [
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil,
	key1: 150,
	key2: "string"
	]
	end

	test "trandformed keyword" do
	assert ConfigDB.to_elixir_types(a: 1, b: 2, c: "string") == [a: 1, b: 2, c: "string"]
	end

	test "complex keyword with nested mixed children" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	%{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	%{"tuple" => [":link_name", true]},
	%{"tuple" => [":proxy_remote", false]},
	%{"tuple" => [":common_map", %{":key" => "value"}]},
	%{
	"tuple" => [
	":proxy_opts",
	[
	%{"tuple" => [":redirect_on_failure", false]},
	%{"tuple" => [":max_body_length", 1_048_576]},
	%{
	"tuple" => [
	":http",
	[
	%{"tuple" => [":follow_redirect", true]},
	%{"tuple" => [":pool", ":upload"]}
	]
	]
	}
	]
	]
	}
	]) == [
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_remote: false,
	common_map: %{key: "value"},
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]
	]
	end

	test "common keyword" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":level", ":warning"]},
	%{"tuple" => [":meta", [":all"]]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":val", nil]},
	%{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	]) == [
	level: :warning,
	meta: [:all],
	path: "",
	val: nil,
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex keyword with sigil" do
	assert ConfigDB.to_elixir_types([
	%{"tuple" => [":federated_timeline_removal", []]},
	%{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	%{"tuple" => [":replace", []]}
	]) == [
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	]
	end

	test "complex keyword with tuples with more than 2 values" do
	assert ConfigDB.to_elixir_types([
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key1",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]) == [
	http: [
	key1: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	]
	]
	end
	end
	end
	diff --git a/test/pleroma/http/adapter_helper/gun_test.exs b/test/pleroma/http/adapter_helper/gun_test.exs
	index d567bc844..568fd6fb3 100644
	--- a/test/pleroma/http/adapter_helper/gun_test.exs
	+++ b/test/pleroma/http/adapter_helper/gun_test.exs
	@@ -1,77 +1,77 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.AdapterHelper.GunTest do
	use ExUnit.Case
	use Pleroma.Tests.Helpers

	import Mox

	alias Pleroma.HTTP.AdapterHelper.Gun

	setup :verify_on_exit!

	describe "options/1" do
	setup do: clear_config([:http, :adapter], a: 1, b: 2)

	test "https url with default port" do
	uri = URI.parse("https://example.com")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv4 with default port" do
	uri = URI.parse("https://127.0.0.1")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https ipv6 with default port" do
	uri = URI.parse("https://[2a03:2880:f10c:83:face:b00c:0:25de]")

	opts = Gun.options([receive_conn: false], uri)
	assert opts[:certificates_verification]
	end

	test "https url with non-standard port" do
	uri = URI.parse("https://example.com:115")

	opts = Gun.options([receive_conn: false], uri)

	assert opts[:certificates_verification]
	end

	test "merges with default http adapter config" do
	defaults = Gun.options([receive_conn: false], URI.parse("https://example.com"))
	assert Keyword.has_key?(defaults, :a)
	assert Keyword.has_key?(defaults, :b)
	end

	test "parses string proxy host & port" do
	clear_config([:http, :proxy_url], "localhost:8123")

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	- assert opts[:proxy] == {'localhost', 8123}
	+ assert opts[:proxy] == {~c"localhost", 8123}
	end

	test "parses tuple proxy scheme host and port" do
	- clear_config([:http, :proxy_url], {:socks, 'localhost', 1234})
	+ clear_config([:http, :proxy_url], {:socks, ~c"localhost", 1234})

	uri = URI.parse("https://some-domain.com")
	opts = Gun.options([receive_conn: false], uri)
	- assert opts[:proxy] == {:socks, 'localhost', 1234}
	+ assert opts[:proxy] == {:socks, ~c"localhost", 1234}
	end

	test "passed opts have more weight than defaults" do
	- clear_config([:http, :proxy_url], {:socks5, 'localhost', 1234})
	+ clear_config([:http, :proxy_url], {:socks5, ~c"localhost", 1234})
	uri = URI.parse("https://some-domain.com")
	- opts = Gun.options([receive_conn: false, proxy: {'example.com', 4321}], uri)
	+ opts = Gun.options([receive_conn: false, proxy: {~c"example.com", 4321}], uri)

	- assert opts[:proxy] == {'example.com', 4321}
	+ assert opts[:proxy] == {~c"example.com", 4321}
	end
	end
	end
	diff --git a/test/pleroma/http/adapter_helper_test.exs b/test/pleroma/http/adapter_helper_test.exs
	index e3c78f317..cc0e24167 100644
	--- a/test/pleroma/http/adapter_helper_test.exs
	+++ b/test/pleroma/http/adapter_helper_test.exs
	@@ -1,28 +1,28 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.AdapterHelperTest do
	use ExUnit.Case, async: true

	alias Pleroma.HTTP.AdapterHelper

	describe "format_proxy/1" do
	test "with nil" do
	assert AdapterHelper.format_proxy(nil) == nil
	end

	test "with string" do
	assert AdapterHelper.format_proxy("127.0.0.1:8123") == {{127, 0, 0, 1}, 8123}
	end

	test "localhost with port" do
	- assert AdapterHelper.format_proxy("localhost:8123") == {'localhost', 8123}
	+ assert AdapterHelper.format_proxy("localhost:8123") == {~c"localhost", 8123}
	end

	test "tuple" do
	assert AdapterHelper.format_proxy({:socks4, :localhost, 9050}) ==
	- {:socks4, 'localhost', 9050}
	+ {:socks4, ~c"localhost", 9050}
	end
	end
	end
	diff --git a/test/pleroma/job_queue_monitor_test.exs b/test/pleroma/job_queue_monitor_test.exs
	index f2056990f..e2250d7e2 100644
	--- a/test/pleroma/job_queue_monitor_test.exs
	+++ b/test/pleroma/job_queue_monitor_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.JobQueueMonitorTest do
	use ExUnit.Case, async: true

	alias Pleroma.JobQueueMonitor

	@success {:process_event, :success, 1337,
	%{
	args: %{"op" => "refresh_subscriptions"},
	attempt: 1,
	id: 339,
	max_attempts: 5,
	queue: "federator_outgoing",
	worker: "Pleroma.Workers.SubscriberWorker"
	}}

	@failure {:process_event, :failure, 22_521_134,
	%{
	args: %{"op" => "force_password_reset", "user_id" => "9nJG6n6Nbu7tj9GJX6"},
	attempt: 1,
	error: %RuntimeError{message: "oops"},
	id: 345,
	kind: :exception,
	max_attempts: 1,
	queue: "background",
	stack: [
	{Pleroma.Workers.BackgroundWorker, :perform, 2,
	- [file: 'lib/pleroma/workers/background_worker.ex', line: 31]},
	+ [file: ~c"lib/pleroma/workers/background_worker.ex", line: 31]},
	{Oban.Queue.Executor, :safe_call, 1,
	- [file: 'lib/oban/queue/executor.ex', line: 42]},
	- {:timer, :tc, 3, [file: 'timer.erl', line: 197]},
	- {Oban.Queue.Executor, :call, 2, [file: 'lib/oban/queue/executor.ex', line: 23]},
	- {Task.Supervised, :invoke_mfa, 2, [file: 'lib/task/supervised.ex', line: 90]},
	- {:proc_lib, :init_p_do_apply, 3, [file: 'proc_lib.erl', line: 249]}
	+ [file: ~c"lib/oban/queue/executor.ex", line: 42]},
	+ {:timer, :tc, 3, [file: ~c"timer.erl", line: 197]},
	+ {Oban.Queue.Executor, :call, 2, [file: ~c"lib/oban/queue/executor.ex", line: 23]},
	+ {Task.Supervised, :invoke_mfa, 2, [file: ~c"lib/task/supervised.ex", line: 90]},
	+ {:proc_lib, :init_p_do_apply, 3, [file: ~c"proc_lib.erl", line: 249]}
	],
	worker: "Pleroma.Workers.BackgroundWorker"
	}}

	test "stats/0" do
	assert %{processed_jobs: _, queues: _, workers: _} = JobQueueMonitor.stats()
	end

	test "handle_cast/2" do
	state = %{workers: %{}, queues: %{}, processed_jobs: 0}

	assert {:noreply, state} = JobQueueMonitor.handle_cast(@success, state)
	assert {:noreply, state} = JobQueueMonitor.handle_cast(@failure, state)
	assert {:noreply, state} = JobQueueMonitor.handle_cast(@success, state)
	assert {:noreply, state} = JobQueueMonitor.handle_cast(@failure, state)

	assert state == %{
	processed_jobs: 4,
	queues: %{
	"background" => %{failure: 2, processed_jobs: 2, success: 0},
	"federator_outgoing" => %{failure: 0, processed_jobs: 2, success: 2}
	},
	workers: %{
	"Pleroma.Workers.BackgroundWorker" => %{
	"force_password_reset" => %{failure: 2, processed_jobs: 2, success: 0}
	},
	"Pleroma.Workers.SubscriberWorker" => %{
	"refresh_subscriptions" => %{failure: 0, processed_jobs: 2, success: 2}
	}
	}
	}
	end
	end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index 2c582c708..21bea4c3f 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1122 +1,1125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase, async: false

	import Pleroma.Factory

	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView

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

	describe "create_notifications" do
	test "never returns nil" do
	user = insert(:user)
	other_user = insert(:user, %{invisible: true})

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	refute {:ok, [nil]} == Notification.create_notifications(activity)
	end

	test "creates a report notification only for privileged users" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	clear_config([:instance, :moderator_privileges], [])
	{:ok, activity1} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, []} = Notification.create_notifications(activity1)

	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
	{:ok, activity2} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity2)

	assert notification.user_id == moderator_user.id
	assert notification.type == "pleroma:report"
	end

	test "suppresses notifications for own reports" do
	clear_config([:instance, :admin_privileges], [:reports_manage_reports])

	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

	{:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})

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

	refute notification.user_id == reporting_admin.id
	assert notification.user_id == other_admin.id
	assert notification.type == "pleroma:report"
	end

	test "creates a notification for an emoji reaction" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

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

	assert notification.user_id == user.id
	assert notification.type == "pleroma:emoji_reaction"
	end

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

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

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

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

	assert [%Pleroma.Marker{unread_count: 2}] =
	Pleroma.Marker.get_markers(other_user, ["notifications"])
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	assert notification.type == "status"
	end

	test "does not create a notification for subscribed users if status is a reply" do
	user = insert(:user)
	other_user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, other_user)

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

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

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

	subscriber_notifications = Notification.for_user(subscriber)
	assert Enum.empty?(subscriber_notifications)
	end

	test "does not create subscriber notification if mentioned" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, status} = CommonAPI.post(user, %{status: "mentioning @#{subscriber.nickname}"})
	{:ok, [notification] = notifications} = Notification.create_notifications(status)

	assert length(notifications) == 1

	assert notification.user_id == subscriber.id
	assert notification.type == "mention"
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

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

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

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

	assert [%{type: "reblog"}] = Notification.for_user(user)
	assert [%{type: "update"}] = Notification.for_user(repeated_user)
	assert [%{type: "mention"}] = Notification.for_user(other_user)
	end
	end

	test "create_poll_notifications/1" do
	[user1, user2, user3, _, _] = insert_list(5, :user)
	question = insert(:question, user: user1)
	activity = insert(:question_activity, question: question)

	{:ok, _, _} = CommonAPI.vote(user2, question, [0])
	{:ok, _, _} = CommonAPI.vote(user3, question, [1])

	{:ok, notifications} = Notification.create_poll_notifications(activity)

	assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
	end

	describe "create_notification" do
	test "it disables notifications from strangers" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followees" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(follower, followed)
	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it allows notifications from followees" do
	poster = insert(:user)

	receiver =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	CommonAPI.follow(receiver, poster)
	{:ok, activity} = CommonAPI.post(poster, %{status: "hey @#{receiver.nickname}"})
	assert Notification.create_notification(activity, receiver)
	end

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

	refute Notification.create_notification(activity, author)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(subscriber, user)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

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

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it disables notifications from people who are invisible" do
	author = insert(:user, invisible: true)
	user = insert(:user)

	{:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
	refute Notification.create_notification(status, user)
	end

	test "it doesn't create notifications if content matches with an irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: true)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it creates notifications if content matches with a not irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: false)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification
	refute notification.seen
	end

	test "it creates notifications when someone likes user's status with a filtered word" do
	user = insert(:user)
	other_user = insert(:user)
	insert(:filter, user: user, phrase: "tesla", hide: true)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
	{:ok, activity_two} = CommonAPI.favorite(other_user, activity_one.id)

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

	assert notification
	refute notification.seen
	end
	end

	describe "follow / follow_request notifications" do
	test "it creates `follow` notification for approved Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end

	test "it creates `follow_request` notification for pending Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: true)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	render_opts = %{notification: notification, for: followed_user}
	assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)

	# After request is accepted, the same notification is rendered with type "follow":
	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	notification =
	Repo.get(Notification, notification.id)
	\|> Repo.preload(:activity)

	assert %{type: "follow"} =
	- NotificationView.render("show.json", notification: notification, for: followed_user)
	+ NotificationView.render("show.json",
	+ notification: notification,
	+ for: followed_user
	+ )
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	CommonAPI.unfollow(user, followed_user)
	{:ok, _, _, _activity_dupe} = CommonAPI.follow(user, followed_user)

	notification_id = notification.id
	assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
	end

	test "dismisses the notification on follow request rejection" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	{:ok, _, _, _follow_activity} = CommonAPI.follow(follower, user)
	assert [_notification] = Notification.for_user(user)
	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
	assert [] = Notification.for_user(user)
	end
	end

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

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

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

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

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

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

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

	[n2, n1] = Notification.for_user(other_user)

	assert n2.id > n1.id

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

	Notification.set_read_up_to(other_user, n2.id)

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

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

	assert %Pleroma.Marker{} =
	m =
	Pleroma.Repo.get_by(
	Pleroma.Marker,
	user_id: other_user.id,
	timeline: "notifications"
	)

	assert m.last_read_id == to_string(n2.id)
	end
	end

	describe "for_user_since/2" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Returns recent notifications" do
	user1 = insert(:user)
	user2 = insert(:user)

	Enum.each(0..10, fn i ->
	{:ok, _activity} =
	CommonAPI.post(user1, %{
	status: "hey ##{i} @#{user2.nickname}!"
	})
	end)

	{old, new} = Enum.split(Notification.for_user(user2), 5)

	Enum.each(old, fn notification ->
	notification
	\|> cast(%{updated_at: days_ago(10)}, [:updated_at])
	\|> Pleroma.Repo.update!()
	end)

	recent_notifications_ids =
	user2
	\|> Notification.for_user_since(
	NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
	)
	\|> Enum.map(& &1.id)

	Enum.each(old, fn %{id: id} ->
	refute id in recent_notifications_ids
	end)

	Enum.each(new, fn %{id: id} ->
	assert id in recent_notifications_ids
	end)
	end
	end

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it only notifies the post's author in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, like_data, _} = Builder.like(third_user, activity_one.object)

	{:ok, like, _} =
	like_data
	\|> Map.put("to", [other_user.ap_id \| like_data["to"]])
	\|> ActivityPub.persist(local: true)

	enabled_receivers = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it does not return blocking recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(other_user, user)

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return notification-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationships} = User.mute(other_user, user)

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it does not return thread-muting recipient in recipients list" do
	user = insert(:user)
	other_user = insert(:user)

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

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

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

	enabled_receivers = Notification.get_notified_from_activity(same_context_activity)

	refute other_user in enabled_receivers
	end

	test "it does not return non-following domain-blocking recipient in recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	end

	test "it returns following domain-blocking recipient in enabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)
	{:ok, other_user, user} = User.follow(other_user, user)

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

	enabled_receivers = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	end

	test "it sends edited notifications to those who repeated a status" do
	user = insert(:user)
	repeated_user = insert(:user)
	other_user = insert(:user)

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

	{:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)

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

	enabled_receivers = Notification.get_notified_from_activity(edit_activity)

	assert repeated_user in enabled_receivers
	refute other_user in enabled_receivers
	end
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

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

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

	assert Enum.empty?(Notification.for_user(user))
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

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

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

	assert Enum.empty?(Notification.for_user(user))
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

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

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

	assert Enum.empty?(Notification.for_user(user))
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

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

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

	assert Enum.empty?(Notification.for_user(user))
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))
	end

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

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))

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

	assert Enum.empty?(Notification.for_user(user))
	end

	test "notifications are deleted if a local user is deleted" do
	user = insert(:user)
	other_user = insert(:user)

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

	refute Enum.empty?(Notification.for_user(other_user))

	{:ok, job} = User.delete(user)
	ObanHelpers.perform(job)

	assert Enum.empty?(Notification.for_user(other_user))
	end

	test "notifications are deleted if a remote user is deleted" do
	remote_user = insert(:user)
	local_user = insert(:user)

	dm_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => remote_user.ap_id,
	"id" => remote_user.ap_id <> "/activities/test",
	"to" => [local_user.ap_id],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => remote_user.ap_id <> "/objects/test",
	"content" => "Hello!",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => local_user.ap_id,
	"name" => "@#{local_user.nickname}"
	}
	],
	"to" => [local_user.ap_id],
	"cc" => [],
	"attributedTo" => remote_user.ap_id
	}
	}

	{:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)

	refute Enum.empty?(Notification.for_user(local_user))

	delete_user_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => remote_user.ap_id <> "/activities/delete",
	"actor" => remote_user.ap_id,
	"type" => "Delete",
	"object" => remote_user.ap_id
	}

	remote_user_url = remote_user.ap_id

	Tesla.Mock.mock(fn
	%{method: :get, url: ^remote_user_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	{:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
	ObanHelpers.perform_all()

	assert Enum.empty?(Notification.for_user(local_user))
	end

	test "move activity generates a notification" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	other_follower = insert(:user, %{allow_following_move: false})

	User.follow(follower, old_user)
	User.follow(other_follower, old_user)

	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	ObanHelpers.perform_all()

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(other_follower)
	end
	end

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

	{:ok, %{user: user}}
	end

	test "it returns notifications for muted user without notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, %{notifications: false})

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

	test "it doesn't return notifications for muted user with notifications", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user", %{user: user} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for domain-blocked non-followed user", %{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Notification.for_user(user) == []
	end

	test "it returns notifications for domain-blocked but followed user" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")

	{:ok, user} = User.block_domain(user, "some-domain.com")
	{:ok, _, _} = User.follow(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

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

	test "it doesn't return notifications for muted thread", %{user: user} do
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications from a muted user when with_muted is set", %{user: user} do
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

	{:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it doesn't return notifications from a blocked user when with_muted is set", %{
	user: user
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "when with_muted is set, " <>
	"it doesn't return notifications from a domain-blocked non-followed user",
	%{user: user} do
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

	{:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

	test "it returns notifications from muted threads when with_muted is set", %{user: user} do
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications about mentions with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})

	assert Enum.empty?(Notification.for_user(user))
	end

	test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "test", hide: false)
	another_user = insert(:user)

	{:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})

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

	test "it returns notifications about favorites with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
	{:ok, _} = CommonAPI.favorite(another_user, activity.id)

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

	test "it returns notifications when related object is without content and filters are defined",
	%{user: user} do
	followed_user = insert(:user, is_locked: true)

	insert(:filter, user: followed_user, phrase: "test", hide: true)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow_request"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})

	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end
	end
	end
	diff --git a/test/pleroma/user/backup_test.exs b/test/pleroma/user/backup_test.exs
	index 5503d15bc..753e35982 100644
	--- a/test/pleroma/user/backup_test.exs
	+++ b/test/pleroma/user/backup_test.exs
	@@ -1,372 +1,372 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.BackupTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	import Mock
	import Pleroma.Factory
	import Swoosh.TestAssertions
	import Mox

	alias Pleroma.Bookmark
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Uploaders.S3.ExAwsMock
	alias Pleroma.User.Backup
	alias Pleroma.User.Backup.ProcessorMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Workers.BackupWorker

	setup do
	clear_config([Pleroma.Upload, :uploader])
	clear_config([Backup, :limit_days])
	clear_config([Pleroma.Emails.Mailer, :enabled], true)

	ConfigMock
	\|> stub_with(Pleroma.Config)

	ProcessorMock
	\|> stub_with(Pleroma.User.Backup.Processor)

	:ok
	end

	test "it does not requrie enabled email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	user = insert(:user)
	assert {:ok, _} = Backup.create(user)
	end

	test "it does not require user's email" do
	user = insert(:user, %{email: nil})
	assert {:ok, _} = Backup.create(user)
	end

	test "it creates a backup record and an Oban job" do
	%{id: user_id} = user = insert(:user)
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	assert_enqueued(worker: BackupWorker, args: args)

	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0, state: :pending} = backup
	end

	test "it return an error if the export limit is over" do
	%{id: user_id} = user = insert(:user)
	limit_days = Pleroma.Config.get([Backup, :limit_days])
	assert {:ok, %Oban.Job{args: args}} = Backup.create(user)
	backup = Backup.get(args["backup_id"])
	assert %Backup{user_id: ^user_id, processed: false, file_size: 0} = backup

	assert Backup.create(user) == {:error, "Last export was less than #{limit_days} days ago"}
	end

	test "it process a backup record" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id, state: :complete} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it updates states of the backup" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id, state: :complete} = backup

	delete_job_args = %{"op" => "delete", "backup_id" => backup_id}

	assert_enqueued(worker: BackupWorker, args: delete_job_args)
	assert {:ok, backup} = perform_job(BackupWorker, delete_job_args)
	refute Backup.get(backup_id)

	email = Pleroma.Emails.UserEmail.backup_is_ready_email(backup)

	assert_email_sent(
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "it does not send an email if the user does not have an email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: nil})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if mailer is not on" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user)

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it does not send an email if the user has an empty email" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	%{id: user_id} = user = insert(:user, %{email: ""})

	assert {:ok, %Oban.Job{args: %{"backup_id" => backup_id} = args}} = Backup.create(user)
	assert {:ok, backup} = perform_job(BackupWorker, args)
	assert backup.file_size > 0
	assert %Backup{id: ^backup_id, processed: true, user_id: ^user_id} = backup

	assert_no_email_sent()
	end

	test "it removes outdated backups after creating a fresh one" do
	clear_config([Backup, :limit_days], -1)
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	user = insert(:user)

	assert {:ok, job1} = Backup.create(user)

	assert {:ok, %Backup{}} = ObanHelpers.perform(job1)
	assert {:ok, job2} = Backup.create(user)
	assert Pleroma.Repo.aggregate(Backup, :count) == 2
	assert {:ok, backup2} = ObanHelpers.perform(job2)

	ObanHelpers.perform_all()

	assert [^backup2] = Pleroma.Repo.all(Backup)
	end

	test "it creates a zip archive with user data" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})
	%{ap_id: other_ap_id} = other_user = insert(:user)

	{:ok, %{object: %{data: %{"id" => id1}}} = status1} =
	CommonAPI.post(user, %{status: "status1"})

	{:ok, %{object: %{data: %{"id" => id2}}} = status2} =
	CommonAPI.post(user, %{status: "status2"})

	{:ok, %{object: %{data: %{"id" => id3}}} = status3} =
	CommonAPI.post(user, %{status: "status3"})

	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)

	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	CommonAPI.follow(user, other_user)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup, self())
	assert {:ok, zipfile} = :zip.zip_open(String.to_charlist(path), [:memory])
	- assert {:ok, {'actor.json', json}} = :zip.zip_get('actor.json', zipfile)
	+ assert {:ok, {~c"actor.json", json}} = :zip.zip_get(~c"actor.json", zipfile)

	assert %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{"@language" => "und"}
	],
	"bookmarks" => "bookmarks.json",
	"followers" => "http://cofe.io/users/cofe/followers",
	"following" => "http://cofe.io/users/cofe/following",
	"id" => "http://cofe.io/users/cofe",
	"inbox" => "http://cofe.io/users/cofe/inbox",
	"likes" => "likes.json",
	"name" => "Cofe",
	"outbox" => "http://cofe.io/users/cofe/outbox",
	"preferredUsername" => "cofe",
	"publicKey" => %{
	"id" => "http://cofe.io/users/cofe#main-key",
	"owner" => "http://cofe.io/users/cofe"
	},
	"type" => "Person",
	"url" => "http://cofe.io/users/cofe"
	} = Jason.decode!(json)

	- assert {:ok, {'outbox.json', json}} = :zip.zip_get('outbox.json', zipfile)
	+ assert {:ok, {~c"outbox.json", json}} = :zip.zip_get(~c"outbox.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "outbox.json",
	"orderedItems" => [
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status1",
	"type" => "Note"
	},
	"type" => "Create"
	},
	%{
	"object" => %{
	"actor" => "http://cofe.io/users/cofe",
	"content" => "status2"
	}
	},
	%{
	"actor" => "http://cofe.io/users/cofe",
	"object" => %{
	"content" => "status3"
	}
	}
	],
	"totalItems" => 3,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	- assert {:ok, {'likes.json', json}} = :zip.zip_get('likes.json', zipfile)
	+ assert {:ok, {~c"likes.json", json}} = :zip.zip_get(~c"likes.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "likes.json",
	"orderedItems" => [^id1, ^id2],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	- assert {:ok, {'bookmarks.json', json}} = :zip.zip_get('bookmarks.json', zipfile)
	+ assert {:ok, {~c"bookmarks.json", json}} = :zip.zip_get(~c"bookmarks.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "bookmarks.json",
	"orderedItems" => [^id2, ^id3],
	"totalItems" => 2,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	- assert {:ok, {'following.json', json}} = :zip.zip_get('following.json', zipfile)
	+ assert {:ok, {~c"following.json", json}} = :zip.zip_get(~c"following.json", zipfile)

	assert %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "following.json",
	"orderedItems" => [^other_ap_id],
	"totalItems" => 1,
	"type" => "OrderedCollection"
	} = Jason.decode!(json)

	:zip.zip_close(zipfile)
	File.rm!(path)
	end

	test "it counts the correct number processed" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	Enum.map(1..120, fn i ->
	{:ok, status} = CommonAPI.post(user, %{status: "status #{i}"})
	CommonAPI.favorite(user, status.id)
	Bookmark.create(user.id, status.id)
	end)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	{:ok, backup} = Backup.process(backup)

	assert backup.processed_number == 1 + 120 + 120 + 120

	Backup.delete(backup)
	end

	test "it handles errors" do
	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	Enum.map(1..120, fn i ->
	{:ok, _status} = CommonAPI.post(user, %{status: "status #{i}"})
	end)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()

	with_mock Pleroma.Web.ActivityPub.Transmogrifier,
	[:passthrough],
	prepare_outgoing: fn data ->
	object =
	data["object"]
	\|> Pleroma.Object.normalize(fetch: false)
	\|> Map.get(:data)

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

	if String.contains?(data["object"]["content"], "119"),
	do: raise(%Postgrex.Error{}),
	else: {:ok, data}
	end do
	{:ok, backup} = Backup.process(backup)
	assert backup.processed
	assert backup.state == :complete
	assert backup.processed_number == 1 + 119

	Backup.delete(backup)
	end
	end

	describe "it uploads and deletes a backup archive" do
	setup do
	clear_config([Pleroma.Upload, :base_url], "https://s3.amazonaws.com")
	clear_config([Pleroma.Uploaders.S3, :bucket], "test_bucket")

	user = insert(:user, %{nickname: "cofe", name: "Cofe", ap_id: "http://cofe.io/users/cofe"})

	{:ok, status1} = CommonAPI.post(user, %{status: "status1"})
	{:ok, status2} = CommonAPI.post(user, %{status: "status2"})
	{:ok, status3} = CommonAPI.post(user, %{status: "status3"})
	CommonAPI.favorite(user, status1.id)
	CommonAPI.favorite(user, status2.id)
	Bookmark.create(user.id, status2.id)
	Bookmark.create(user.id, status3.id)

	assert {:ok, backup} = user \|> Backup.new() \|> Repo.insert()
	assert {:ok, path} = Backup.export(backup, self())

	[path: path, backup: backup]
	end

	test "S3", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.S3)
	clear_config([Pleroma.Uploaders.S3, :streaming_enabled], false)

	ExAwsMock
	\|> expect(:request, 2, fn
	%{http_method: :put} -> {:ok, :ok}
	%{http_method: :delete} -> {:ok, %{status_code: 204}}
	end)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end

	test "Local", %{path: path, backup: backup} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)

	assert {:ok, %Pleroma.Upload{}} = Backup.upload(backup, path)
	assert {:ok, _backup} = Backup.delete(backup)
	end
	end
	end
	diff --git a/test/pleroma/web/feed/tag_controller_test.exs b/test/pleroma/web/feed/tag_controller_test.exs
	index 58ab8f137..7d196b228 100644
	--- a/test/pleroma/web/feed/tag_controller_test.exs
	+++ b/test/pleroma/web/feed/tag_controller_test.exs
	@@ -1,194 +1,194 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.TagControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:feed])

	test "gets a feed (ATOM)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

	object = Object.normalize(activity1, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.atom"))
	\|> response(200)

	xml = parse(response)

	- assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'
	+ assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	- '42 This is :moominmamm...',
	- 'yeah #PleromaArt'
	+ ~c"42 This is :moominmamm...",
	+ ~c"yeah #PleromaArt"
	]

	assert xpath(xml, ~x"//feed/entry/author/name/text()"ls) == [user.nickname, user.nickname]

	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/tags/pleromaart.atom", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/atom+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	- assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'
	+ assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	- 'yeah #PleromaArt'
	+ ~c"yeah #PleromaArt"
	]
	end

	test "gets a feed (RSS)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

	object = Object.normalize(activity1, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	- assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
	+ assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	assert xpath(xml, ~x"//channel/link/text()") ==
	- '#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss'
	+ ~c"#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss"

	assert xpath(xml, ~x"//channel/webfeeds:logo/text()") ==
	- '#{Pleroma.Web.Endpoint.url()}/static/logo.svg'
	+ ~c"#{Pleroma.Web.Endpoint.url()}/static/logo.svg"

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	- '42 This is :moominmamm...',
	- 'yeah #PleromaArt'
	+ ~c"42 This is :moominmamm...",
	+ ~c"yeah #PleromaArt"
	]

	assert xpath(xml, ~x"//channel/item/pubDate/text()"sl) == [
	FeedView.to_rfc2822(activity2.data["published"]),
	FeedView.to_rfc2822(activity1.data["published"])
	]

	assert xpath(xml, ~x"//channel/item/enclosure/@url"sl) == [
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	]

	obj1 = Object.normalize(activity1, fetch: false)
	obj2 = Object.normalize(activity2, fetch: false)

	assert xpath(xml, ~x"//channel/item/description/text()"sl) == [
	HtmlEntities.decode(FeedView.activity_content(obj2.data)),
	HtmlEntities.decode(FeedView.activity_content(obj1.data))
	]

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	- assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
	+ assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	conn =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/tags/pleromaart.rss", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/rss+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	- assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'
	+ assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	- 'yeah #PleromaArt'
	+ ~c"yeah #PleromaArt"
	]
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public], false)

	test "returns 404 for tags feed", %{conn: conn} do
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/feed/user_controller_test.exs b/test/pleroma/web/feed/user_controller_test.exs
	index d3c4108de..1c17d47b4 100644
	--- a/test/pleroma/web/feed/user_controller_test.exs
	+++ b/test/pleroma/web/feed/user_controller_test.exs
	@@ -1,302 +1,302 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:static_fe, :enabled], false)

	describe "feed" do
	setup do: clear_config([:feed])

	setup do
	clear_config(
	[:feed, :post_title],
	%{max_length: 15, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This & this is :moominmamma: note ",
	"source" => "This & this is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"],
	"context" => "2hu & as",
	"summary" => "2hu & as"
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 & This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)

	note3 =
	insert(:note,
	user: user,
	data: %{
	"content" => "This note tests whether HTML entities are truncated properly",
	"summary" => "Won't, didn't fail",
	"inReplyTo" => note_activity2.id
	}
	)

	_note_activity3 = insert(:note_activity, note: note3)
	object = Object.normalize(note_activity, fetch: false)

	encoded_title = FeedView.activity_title(note3.data)

	[user: user, object: object, max_id: note_activity2.id, encoded_title: encoded_title]
	end

	test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	- assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
	+ assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	- assert activity_titles == ['2hu & as']
	+ assert activity_titles == [~c"2hu & as"]
	end

	test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	- assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
	+ assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	- assert activity_titles == ['2hu & as']
	+ assert activity_titles == [~c"2hu & as"]
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, "nonexisting"))

	assert response(conn, 404)
	end

	test "returns feed with public and unlisted activities", %{conn: conn} do
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
	{:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
	{:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
	{:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)
	\|> Enum.sort()

	- assert activity_titles == ['public', 'unlisted']
	+ assert activity_titles == [~c"public", ~c"unlisted"]
	end

	test "returns 404 when the user is remote", %{conn: conn} do
	user = insert(:user, local: false)

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

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)
	end

	test "does not mangle HTML entities midway", %{
	conn: conn,
	user: user,
	object: object,
	encoded_title: encoded_title
	} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	- assert activity_titles == ['Won\'t, didn\'...', '2hu', '2hu & as']
	+ assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])
	assert resp =~ encoded_title
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "feed_redirect" do
	test "with html format, it redirects to user feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

	assert response ==
	Pleroma.Web.Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "with html format, it falls back to frontend when user is remote", %{conn: conn} do
	user = insert(:user, local: false)

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

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

	assert response =~ "</html>"
	end

	test "with html format, it falls back to frontend when user is not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> response(200)

	assert response =~ "</html>"
	end

	test "with non-html / non-json format, it redirects to user feed in atom format", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

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

	assert conn.status == 302

	assert redirected_to(conn) ==
	"#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.atom"
	end

	test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(user_feed_path(conn, :feed, "jimm"))
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public])

	test "returns 404 for user feed", %{conn: conn} do
	clear_config([:instance, :public], false)
	user = insert(:user)

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

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/status_view_test.exs b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	index 167692dfb..b341e43d4 100644
	--- a/test/pleroma/web/mastodon_api/views/status_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	@@ -1,982 +1,984 @@
	# 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.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Conversation.Participation
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.RichMedia.Card

	require Bitwise

	import Mox
	import OpenApiSpex.TestAssertions
	import Pleroma.Factory
	import Tesla.Mock

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

	test "has an emoji reaction list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, ":dinosaur:")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: false, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: false,
	name: "dinosaur",
	url: "http://localhost:4001/emoji/dino walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: true, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: true,
	name: "dinosaur",
	url: "http://localhost:4001/emoji/dino walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]
	end

	test "works with legacy-formatted reactions" do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	activity = insert(:note_activity, user: user, note: note)

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "😿", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]
	end

	test "works correctly with badly formatted emojis" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "yo"})

	activity
	\|> Object.normalize(fetch: false)
	\|> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})

	activity = Activity.get_by_id(activity.id)
	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [user.id]}
	]
	end

	test "doesn't show reactions from muted and blocked users" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

	{:ok, _} = User.mute(user, other_user)
	{:ok, _} = User.block(other_user, third_user)

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "☕")

	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{
	name: "☕",
	count: 2,
	me: false,
	url: nil,
	account_ids: [third_user.id, other_user.id]
	}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: other_user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [other_user.id]}
	]
	end

	test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	with_direct_conversation_id: true,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id

	status = StatusView.render("show.json", activity: activity, for: user)
	assert status[:pleroma][:direct_conversation_id] == nil
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns the direct conversation id when given the `direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	direct_conversation_id: participation.id,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	@tag capture_log: true
	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	Repo.delete(user)
	User.invalidate_cache(user)

	finger_url =
	"https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"

	Tesla.Mock.mock_global(fn
	%{method: :get, url: "http://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{method: :get, url: "https://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{
	method: :get,
	url: ^finger_url
	} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	%{account: ms_user} = StatusView.render("show.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	User.invalidate_cache(user)

	result = StatusView.render("show.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note with null content" do
	note = insert(:note_activity)
	note_object = Object.normalize(note, fetch: false)

	data =
	note_object.data
	\|> Map.put("content", nil)

	Object.change(note_object, %{data: data})
	\|> Object.update_and_set_cache()

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("show.json", %{activity: note})

	assert status.content == ""
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note activity" do
	note = insert(:note_activity)
	object_data = Object.normalize(note, fetch: false).data
	user = User.get_cached_by_ap_id(note.data["actor"])

	convo_id = :erlang.crc32(object_data["context"]) \|> Bitwise.band(Bitwise.bnot(0x8000_0000))

	status = StatusView.render("show.json", %{activity: note})

	created_at =
	(object_data["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: object_data["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HTML.filter_tags(object_data["content"]),
	text: nil,
	created_at: created_at,
	edited_at: nil,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	poll: nil,
	spoiler_text: HTML.filter_tags(object_data["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{hd(object_data["tag"])}",
	url: "http://localhost:4001/tag/#{hd(object_data["tag"])}"
	}
	],
	application: nil,
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	conversation_id: convo_id,
	context: object_data["context"],
	in_reply_to_account_acct: nil,
	quote: nil,
	quote_id: nil,
	quote_url: nil,
	quote_visible: false,
	content: %{"text/plain" => HTML.strip_tags(object_data["content"])},
	spoiler_text: %{"text/plain" => HTML.strip_tags(object_data["summary"])},
	expires_at: nil,
	direct_conversation_id: nil,
	thread_muted: false,
	emoji_reactions: [],
	parent_visible: false,
	pinned_at: nil,
	quotes_count: 0,
	bookmark_folder: nil
	}
	}

	assert status == expected
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])

	opts = %{activity: activity}
	status = StatusView.render("show.json", opts)
	assert status.muted == false
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
	assert status.muted == false

	for_opts = %{activity: activity, for: user}
	status = StatusView.render("show.json", for_opts)
	assert status.muted == true

	status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
	assert status.muted == true
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is thread muted" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == false

	{:ok, activity} = CommonAPI.add_mute(user, activity)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == true
	end

	test "tells if the status is bookmarked" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
	status = StatusView.render("show.json", %{activity: activity})

	assert status.bookmarked == false

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == false

	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)

	activity = Activity.get_by_id_with_object(activity.id)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == true
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})

	status = StatusView.render("show.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "a quote post" do
	post = insert(:note_activity)
	user = insert(:user)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quote_id: post.id})
	{:ok, quoted_quote_post} = CommonAPI.post(user, %{status: "yo", quote_id: quote_post.id})

	status = StatusView.render("show.json", %{activity: quoted_quote_post})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	assert status.pleroma.quote_id == to_string(quote_post.id)
	assert status.pleroma.quote_url == Object.normalize(quote_post).data["id"]
	assert status.pleroma.quote_visible

	# Quotes don't go more than one level deep
	refute status.pleroma.quote.pleroma.quote
	assert status.pleroma.quote.pleroma.quote_id == to_string(post.id)
	assert status.pleroma.quote.pleroma.quote_url == Object.normalize(post).data["id"]
	assert status.pleroma.quote.pleroma.quote_visible

	# In an index
	[status] = StatusView.render("index.json", %{activities: [quoted_quote_post], as: :activity})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	end

	test "quoted private post" do
	user = insert(:user)

	# Insert a private post
	private = insert(:followers_only_note_activity, user: user)
	private_object = Object.normalize(private)

	# Create a public post quoting the private post
	quote_private =
	- insert(:note_activity, note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]}))
	+ insert(:note_activity,
	+ note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]})
	+ )

	status = StatusView.render("show.json", %{activity: quote_private})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == private_object.data["id"]
	refute status.pleroma.quote_visible

	# After following the user, the quote is rendered
	follower = insert(:user)
	CommonAPI.follow(follower, user)

	status = StatusView.render("show.json", %{activity: quote_private, for: follower})
	assert status.pleroma.quote.id == to_string(private.id)
	assert status.pleroma.quote_visible
	end

	test "quoted direct message" do
	# Insert a direct message
	direct = insert(:direct_note_activity)
	direct_object = Object.normalize(direct)

	# Create a public post quoting the direct message
	quote_direct =
	insert(:note_activity, note: insert(:note, data: %{"quoteUrl" => direct_object.data["id"]}))

	status = StatusView.render("show.json", %{activity: quote_direct})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == direct_object.data["id"]
	refute status.pleroma.quote_visible
	end

	test "repost of quote post" do
	post = insert(:note_activity)
	user = insert(:user)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quote_id: post.id})
	{:ok, repost} = CommonAPI.repeat(quote_post.id, user)

	[status] = StatusView.render("index.json", %{activities: [repost], as: :activity})

	assert status.reblog.pleroma.quote.id == to_string(post.id)
	end

	test "contains mentions" do
	user = insert(:user)
	mentioned = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})

	status = StatusView.render("show.json", %{activity: activity})

	assert status.mentions ==
	Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "create mentions from the 'to' field" do
	%User{ap_id: recipient_ap_id} = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"to" => [recipient_ap_id],
	"cc" => cc
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient_ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient_ap_id
	end

	test "create mentions from the 'tag' field" do
	recipient = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"cc" => cc,
	"tag" => [
	%{
	"href" => recipient.ap_id,
	"name" => recipient.nickname,
	"type" => "Mention"
	},
	%{
	"href" => "https://example.com/search?tag=test",
	"name" => "#test",
	"type" => "Hashtag"
	}
	]
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient.ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient.ap_id
	end

	describe "attachments" do
	test "Complete Mastodon style" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl",
	"width" => 200,
	"height" => 100
	}
	],
	"blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn",
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"},
	meta: %{original: %{width: 200, height: 100, aspect: 2}},
	blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	result = StatusView.render("attachment.json", %{attachment: object})

	assert %{id: "2"} = result
	assert_schema(result, "Attachment", api_spec)
	end

	test "Honkerific" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"name" => "fool.jpeg",
	"summary" => "they have played us for absolute fools."
	}

	expected = %{
	blurhash: nil,
	description: "they have played us for absolute fools.",
	id: "1638338801",
	pleroma: %{mime_type: "image/png", name: "fool.jpeg"},
	preview_url: "someurl",
	remote_url: "someurl",
	text_url: "someurl",
	type: "image",
	url: "someurl"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)
	end
	end

	test "put the url advertised in the Activity in to the url attribute" do
	id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
	[activity] = Activity.search(nil, id)

	status = StatusView.render("show.json", %{activity: activity})

	assert status.uri == id
	assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("show.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "funkwhale audio" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	test "a Mobilizon event" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)

	assert represented[:url] ==
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"

	assert represented[:content] ==
	"<p><a href=\"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39\">Mobilizon Launching Party</a></p><p>Mobilizon is now federated! 🎉</p><p></p><p>You can view this event from other instances if they are subscribed to mobilizon.org, and soon directly from Mastodon and Pleroma. It is possible that you may see some comments from other instances, including Mastodon ones, just below.</p><p></p><p>With a Mobilizon account on an instance, you may <strong>participate</strong> at events from other instances and <strong>add comments</strong> on events.</p><p></p><p>Of course, it's still <u>a work in progress</u>: if reports made from an instance on events and comments can be federated, you can't block people right now, and moderators actions are rather limited, but this <strong>will definitely get fixed over time</strong> until first stable version next year.</p><p></p><p>Anyway, if you want to come up with some feedback, head over to our forum or - if you feel you have technical skills and are familiar with it - on our Gitlab repository.</p><p></p><p>Also, to people that want to set Mobilizon themselves even though we really don't advise to do that for now, we have a little documentation but it's quite the early days and you'll probably need some help. No worries, you can chat with us on our Forum or though our Matrix channel.</p><p></p><p>Check our website for more informations and follow us on Twitter or Mastodon.</p>"
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "http://localhost:4001/tag/fediverse"},
	%{name: "mastodon", url: "http://localhost:4001/tag/mastodon"},
	%{name: "nextcloud", url: "http://localhost:4001/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "https://example.com"

	{:ok, card} =
	Card.create(page_url, %{image: page_url <> "/example.jpg", title: "Example website"})

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without an image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without descriptions returns the fields with empty strings" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(
	%{description: "", image_description: ""},
	StatusView.render("card.json", card)
	)
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card has all media proxied" do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled])

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

	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"audio" => page_url <> "/example.ogg",
	"video" => page_url <> "/example.mp4",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	%{
	provider_name: "example.com",
	image: image,
	pleroma: %{opengraph: og}
	} = StatusView.render("card.json", card)

	assert String.match?(image, ~r/\/proxy\//)
	assert String.match?(og["image"], ~r/\/proxy\//)
	assert String.match?(og["audio"], ~r/\/proxy\//)
	assert String.match?(og["video"], ~r/\/proxy\//)
	end
	end

	test "does not embed a relationship in the account" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "drink more water"
	})

	result = StatusView.render("show.json", %{activity: activity, for: other_user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "does not embed a relationship in the account in reposts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "˙˙ɐʎns"
	})

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

	result = StatusView.render("show.json", %{activity: activity, for: user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert result[:reblog][:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "visibility/list" do
	user = insert(:user)

	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	status = StatusView.render("show.json", activity: activity)

	assert status.visibility == "list"
	end

	test "has a field for parent visibility" do
	user = insert(:user)
	poster = insert(:user)

	{:ok, invisible} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, visible} =
	CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})

	status = StatusView.render("show.json", activity: visible, for: user)
	refute status.pleroma.parent_visible

	status = StatusView.render("show.json", activity: visible, for: poster)
	assert status.pleroma.parent_visible
	end

	test "it shows edited_at" do
	poster = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	status = StatusView.render("show.json", activity: post)
	refute status.edited_at

	{:ok, _} = CommonAPI.update(poster, post, %{status: "mew mew"})
	edited = Pleroma.Activity.normalize(post)

	status = StatusView.render("show.json", activity: edited)
	assert status.edited_at
	end

	test "with a source object" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("show.json", activity: activity, with_source: true)
	assert status.text == "object source"
	end

	describe "source.json" do
	test "with a source object, renders both source and content type" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "object source"
	assert status.content_type == "text/markdown"
	end

	test "with a source string, renders source and put text/plain as the content type" do
	note = insert(:note, data: %{"source" => "string source"})
	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "string source"
	assert status.content_type == "text/plain"
	end
	end
	end
	diff --git a/test/pleroma/web/o_auth/ldap_authorization_test.exs b/test/pleroma/web/o_auth/ldap_authorization_test.exs
	index 5ab8236b5..07ce2eed8 100644
	--- a/test/pleroma/web/o_auth/ldap_authorization_test.exs
	+++ b/test/pleroma/web/o_auth/ldap_authorization_test.exs
	@@ -1,135 +1,135 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.LDAPAuthorizationTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Token
	import Pleroma.Factory
	import Mock

	@skip if !Code.ensure_loaded?(:eldap), do: :skip

	setup_all do: clear_config([:ldap, :enabled], true)

	setup_all do: clear_config(Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.LDAPAuthenticator)

	@tag @skip
	test "authorizes the existing user using LDAP credentials" do
	password = "testpassword"
	user = insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> :ok end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)

	assert token.user_id == user.id
	assert_received :close_connection
	end
	end

	@tag @skip
	test "creates a new user after successful LDAP authorization" do
	password = "testpassword"
	user = build(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> :ok end,
	equalityMatch: fn _type, _value -> :ok end,
	wholeSubtree: fn -> :ok end,
	search: fn _connection, _options ->
	- {:ok, {:eldap_search_result, [{:eldap_entry, '', []}], []}}
	+ {:ok, {:eldap_search_result, [{:eldap_entry, ~c"", []}], []}}
	end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token) \|> Repo.preload(:user)

	assert token.user.nickname == user.nickname
	assert_received :close_connection
	end
	end

	@tag @skip
	test "disallow authorization for wrong LDAP credentials" do
	password = "testpassword"
	user = insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
	app = insert(:oauth_app, scopes: ["read", "write"])

	host = Pleroma.Config.get([:ldap, :host]) \|> to_charlist
	port = Pleroma.Config.get([:ldap, :port])

	with_mocks [
	{:eldap, [],
	[
	open: fn [^host], [{:port, ^port}, {:ssl, false} \| _] -> {:ok, self()} end,
	simple_bind: fn _connection, _dn, ^password -> {:error, :invalidCredentials} end,
	close: fn _connection ->
	send(self(), :close_connection)
	:ok
	end
	]}
	] do
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"error" => "Invalid credentials"} = json_response(conn, 400)
	assert_received :close_connection
	end
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	index 92334487c..10dcf0e62 100644
	--- a/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	@@ -1,724 +1,724 @@
	# 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.EmojiPackControllerTest do
	use Pleroma.Web.ConnCase, async: false

	import Mock
	import Tesla.Mock
	import Pleroma.Factory

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	setup do: clear_config([:instance, :public], true)

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	admin_conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
	clear_config([:instance, :public], false)
	conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	end

	test "GET /api/pleroma/emoji/packs", %{conn: conn} do
	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	assert resp["count"] == 4

	assert resp["packs"]
	\|> Map.keys()
	\|> length() == 4

	shared = resp["packs"]["test_pack"]
	assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
	assert Map.has_key?(shared["pack"], "download-sha256")
	assert shared["pack"]["can-download"]
	assert shared["pack"]["share-files"]

	non_shared = resp["packs"]["test_pack_nonshared"]
	assert non_shared["pack"]["share-files"] == false
	assert non_shared["pack"]["can-download"] == false

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 4

	packs = Map.keys(resp["packs"])

	assert length(packs) == 1

	[pack1] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 4
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack2] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=3")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 4
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack3] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=4")
	\|> json_response_and_validate_schema(200)

	assert resp["count"] == 4
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack4] = packs
	assert [pack1, pack2, pack3, pack4] \|> Enum.uniq() \|> length() == 4
	end

	describe "GET /api/pleroma/emoji/packs/remote" do
	setup do
	clear_config([:instance, :admin_privileges], [:emoji_manage_emoji])
	end

	test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page=2&page_size=1")
	\|> json_response_and_validate_schema(200)

	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{method: :get, url: "https://example.com/api/v1/pleroma/emoji/packs?page=2&page_size=1"} ->
	json(resp)
	end)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com&page=2&page_size=1")
	\|> json_response_and_validate_schema(200) == resp
	end

	test "non shareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end

	test "it requires privileged role :emoji_manage_emoji", %{admin_conn: admin_conn} do
	clear_config([:instance, :admin_privileges], [])

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response(:forbidden)
	end
	end

	describe "GET /api/pleroma/emoji/packs/archive?name=:name" do
	test "download shared pack", %{conn: conn} do
	resp =
	conn
	\|> get("/api/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)

	{:ok, arch} = :zip.unzip(resp, [:memory])

	- assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
	- assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
	+ assert Enum.find(arch, fn {n, _} -> n == ~c"pack.json" end)
	+ assert Enum.find(arch, fn {n, _} -> n == ~c"blank.png" end)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/archive?name=test_pack_for_import")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack test_pack_for_import does not exist"
	}
	end

	test "non downloadable pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/packs/archive?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(:forbidden) == %{
	"error" =>
	"Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	}
	end
	end

	describe "POST /api/pleroma/emoji/packs/download" do
	setup do
	clear_config([:instance, :admin_privileges], [:emoji_manage_emoji])
	end

	test "shared pack from remote and non shared from fallback-src", %{
	admin_conn: admin_conn,
	conn: conn
	} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack&page_size=" <> _n
	} ->
	conn
	\|> get("/api/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=test_pack"
	} ->
	conn
	\|> get("/api/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)
	\|> text()

	%{
	method: :get,
	url:
	"https://example.com/api/v1/pleroma/emoji/pack?name=test_pack_nonshared&page_size=" <>
	_n
	} ->
	conn
	\|> get("/api/pleroma/emoji/pack?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack2/blank.png")

	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name=test_pack2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack2")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://example.com",
	name: "test_pack_nonshared",
	as: "test_pack_nonshared2"
	}
	)
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")

	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name=test_pack_nonshared2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
	end

	test "nonshareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://old-instance",
	name: "test_pack",
	as: "test_pack2"
	}
	)
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end

	test "checksum fail", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=pack_bad_sha&page_size=" <> _n
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/packs/archive?name=pack_bad_sha"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
	}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "pack_bad_sha",
	as: "pack_bad_sha2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" => "SHA256 for the pack doesn't match the one sent by the server"
	}
	end

	test "other error", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	url: "https://example.com/api/v1/pleroma/emoji/pack?name=test_pack&page_size=" <> _n
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" =>
	"The pack was not set as shared and there is no fallback src to download from"
	}
	end

	test "it requires privileged role :emoji_manage_emoji", %{admin_conn: conn} do
	clear_config([:instance, :admin_privileges], [])

	assert conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response(:forbidden)
	end
	end

	describe "PATCH/update /api/pleroma/emoji/pack?name=:name" do
	setup do
	clear_config([:instance, :admin_privileges], [:emoji_manage_emoji])
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	{:ok,
	pack_file: pack_file,
	new_data: %{
	"license" => "Test license changed",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"share-files" => false
	}}
	end

	test "returns error when file system not writable", %{admin_conn: conn} = ctx do
	with_mocks([
	{File, [:passthrough], [stat: fn _ -> {:error, :eacces} end]}
	]) do
	assert conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch(
	"/api/pleroma/emoji/pack?name=test_pack",
	%{"metadata" => ctx[:new_data]}
	)
	\|> json_response_and_validate_schema(500)
	end
	end

	test "for a pack without a fallback source", ctx do
	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/pack?name=test_pack", %{
	"metadata" => ctx[:new_data]
	})
	\|> json_response_and_validate_schema(200) == ctx[:new_data]

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
	end

	test "for a pack with a fallback source", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	new_data_with_sha =
	Map.put(
	new_data,
	"fallback-src-sha256",
	"1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
	)

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(200) == new_data_with_sha

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
	end

	test "when the fallback source doesn't have all the files", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	- {:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
	+ {:ok, {~c"empty.zip", empty_arch}} = :zip.zip(~c"empty.zip", [], [:memory])
	text(empty_arch)
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "The fallback archive does not have all files specified in pack.json"
	}
	end

	test "it requires privileged role :emoji_manage_emoji", %{
	admin_conn: conn,
	new_data: new_data
	} do
	clear_config([:instance, :admin_privileges], [])

	assert conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response(:forbidden)
	end
	end

	describe "POST/DELETE /api/pleroma/emoji/pack?name=:name" do
	setup do
	clear_config([:instance, :admin_privileges], [:emoji_manage_emoji])
	end

	test "returns an error on creates pack when file system not writable", %{
	admin_conn: admin_conn
	} do
	path_pack = Path.join(@emoji_path, "test_pack")

	with_mocks([
	{File, [:passthrough], [mkdir: fn ^path_pack -> {:error, :eacces} end]}
	]) do
	assert admin_conn
	\|> post("/api/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(500) == %{
	"error" =>
	"Unexpected error occurred while creating pack. (POSIX error: Permission denied)"
	}
	end
	end

	test "returns an error on deletes pack when the file system is not writable", %{
	admin_conn: admin_conn
	} do
	path_pack = Path.join(@emoji_path, "test_emoji_pack")

	try do
	{:ok, _pack} = Pleroma.Emoji.Pack.create("test_emoji_pack")

	with_mocks([
	{File, [:passthrough], [rm_rf: fn ^path_pack -> {:error, :eacces, path_pack} end]}
	]) do
	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name=test_emoji_pack")
	\|> json_response_and_validate_schema(500) == %{
	"error" =>
	"Couldn't delete the `test_emoji_pack` pack (POSIX error: Permission denied)"
	}
	end
	after
	File.rm_rf(path_pack)
	end
	end

	test "creating and deleting a pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_created/pack.json")

	assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
	"pack" => %{},
	"files" => %{},
	"files_count" => 0
	}

	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_created/pack.json")
	end

	test "if pack exists", %{admin_conn: admin_conn} do
	path = Path.join(@emoji_path, "test_created")
	File.mkdir(path)
	pack_file = Jason.encode!(%{files: %{}, pack: %{}})
	File.write!(Path.join(path, "pack.json"), pack_file)

	assert admin_conn
	\|> post("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "A pack named \"test_created\" already exists"
	}

	on_exit(fn -> File.rm_rf(path) end)
	end

	test "with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> post("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end

	test "it requires privileged role :emoji_manage_emoji", %{admin_conn: admin_conn} do
	clear_config([:instance, :admin_privileges], [])

	assert admin_conn
	\|> post("/api/pleroma/emoji/pack?name= ")
	\|> json_response(:forbidden)

	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name= ")
	\|> json_response(:forbidden)
	end
	end

	test "deleting nonexisting pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "deleting with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> delete("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end

	test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
	on_exit(fn ->
	File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	end)

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	refute Map.has_key?(resp["packs"], "test_pack_for_import")

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}

	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")

	emoji_txt_content = """
	blank, blank.png, Fun
	blank2, blank.png
	foo, /emoji/test_pack_for_import/blank.png
	bar
	"""

	File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	assert resp["packs"]["test_pack_for_import"]["files"] == %{
	"blank" => "blank.png",
	"blank2" => "blank.png",
	"foo" => "blank.png"
	}

	clear_config([:instance, :admin_privileges], [])

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response(:forbidden)
	end

	describe "GET /api/pleroma/emoji/pack?name=:name" do
	test "shows pack.json", %{conn: conn} do
	assert %{
	"files" => files,
	"files_count" => 2,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	\|> get("/api/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)

	assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	\|> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1
	end

	test "for pack name with special chars", %{conn: conn} do
	assert %{
	"files" => _files,
	"files_count" => 1,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	\|> get("/api/pleroma/emoji/pack?name=blobs.gg")
	\|> json_response_and_validate_schema(200)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "error name", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end
	end
	diff --git a/test/pleroma/web/push/impl_test.exs b/test/pleroma/web/push/impl_test.exs
	index c263a1280..24bdf37b6 100644
	--- a/test/pleroma/web/push/impl_test.exs
	+++ b/test/pleroma/web/push/impl_test.exs
	@@ -1,405 +1,408 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	use Pleroma.DataCase, async: true

	import Mox
	import Pleroma.Factory

	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription

	setup do
	Tesla.Mock.mock(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis finibus turpis."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	{:ok, activity} = CommonAPI.post(user, %{status: "<Lorem ipsum dolor sit amet."})

	notif =
	insert(:notification,
	user: user,
	activity: activity,
	type: "mention"
	)

	assert Impl.perform(notif) == {:ok, [:ok, :ok]}
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	assert Impl.perform(%{}) == {:error, :unknown_type}
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	@tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subscription if result send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "deletes subscription when token has been deleted" do
	subscription = insert(:push_subscription)

	Pleroma.Repo.delete(subscription.token)

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders title and body for create activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(
	%{
	activity: activity
	},
	user,
	object
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis finibus turpis."

	assert Impl.format_title(%{activity: activity, type: "mention"}) ==
	"New Mention"
	end

	test "renders title and body for follow activity" do
	user = insert(:user, nickname: "Bob")
	other_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, other_user)
	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(%{activity: activity, type: "follow"}, user, object) ==
	"@Bob has followed you"

	assert Impl.format_title(%{activity: activity, type: "follow"}) ==
	"New Follower"
	end

	test "renders title and body for announce activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)
	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(%{activity: announce_activity}, user, object) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis finibus turpis."

	assert Impl.format_title(%{activity: announce_activity, type: "reblog"}) ==
	"New Repeat"
	end

	test "renders title and body for like activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, activity} = CommonAPI.favorite(user, activity.id)
	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(%{activity: activity, type: "favourite"}, user, object) ==
	"@Bob has favorited your post"

	assert Impl.format_title(%{activity: activity, type: "favourite"}) ==
	"New Favorite"
	end

	test "renders title and body for pleroma:emoji_reaction activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "This post is a really good post!"
	})

	{:ok, activity} = CommonAPI.react_with_emoji(activity.id, user, "👍")
	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(%{activity: activity, type: "pleroma:emoji_reaction"}, user, object) ==
	"@Bob reacted with 👍"

	assert Impl.format_title(%{activity: activity, type: "pleroma:emoji_reaction"}) ==
	"New Reaction"
	end

	test "renders title and body for update activity" do
	user = insert(:user)

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

	{:ok, activity} = CommonAPI.update(user, activity, %{status: "edited status"})
	object = Object.normalize(activity, fetch: false)

	assert Impl.format_body(%{activity: activity, type: "update"}, user, object) ==
	"@#{user.nickname} edited a status"

	assert Impl.format_title(%{activity: activity, type: "update"}) ==
	"New Update"
	end

	test "renders title for create activity with direct visibility" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "This is just between you and me, pal"
	})

	assert Impl.format_title(%{activity: activity}) ==
	"New Direct Message"
	end

	test "renders poll notification" do
	user = insert(:user)
	question = insert(:question, user: user)
	activity = insert(:question_activity, question: question)

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

	expected_title = "Poll Results"

	expected_body =
	"""
	Which flavor of ice cream do you prefer?

	○ chocolate
	○ vanilla
	"""
	\|> String.trim_trailing("\n")

	content = Impl.build_content(notification, user, question)

	assert match?(%{title: ^expected_title, body: ^expected_body}, content)
	end

	describe "build_content/3" do
	test "builds content for chat messages" do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(chat, fetch: false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: hey",
	title: "New Chat Message"
	}
	end

	test "builds content for chat messages with no content" do
	user = insert(:user)
	recipient = insert(:user)

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

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

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

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, nil, media_id: upload.id)
	object = Object.normalize(chat, fetch: false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: (Attachment)",
	title: "New Chat Message"
	}
	end

	test "hides contents of notifications when option enabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: true})

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Mention"
	}

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

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Favorite"
	}
	end

	test "returns regular content when hiding contents option disabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	- insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: false})
	+ insert(:user,
	+ nickname: "Rob",
	+ notification_settings: %{hide_notification_contents: false}
	+ )

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis finibus turpis.",
	title: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis finibus turpis.",
	title: "New Mention"
	}

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

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity, fetch: false)

	assert Impl.build_content(notif, actor, object) == %{
	body: "@Bob has favorited your post",
	title: "New Favorite"
	}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 9:26 AM (15 h, 21 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799959
Default Alt Text: (265 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions