No OneTemporary
Actions

Authored By

Unknown

Size

71 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	index da2ddcf42..2fa519291 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,554 +1,552 @@
	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
	+ key: $CI_JOB_IMAGE-$CI_COMMIT_SHORT_SHA
	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
	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 pleroma.test_runner --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
	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 pleroma.test_runner --only=erratic

	formatting-1.15:
	extends: .build_changes_policy
	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/changelog.d/ci-cache.skip b/changelog.d/ci-cache.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/rich_media_backfill.change b/changelog.d/rich_media_backfill.change
	new file mode 100644
	index 000000000..d746ac8ce
	--- /dev/null
	+++ b/changelog.d/rich_media_backfill.change
	@@ -0,0 +1 @@
	+Rich Media backfilling is now an Oban job
	diff --git a/config/test.exs b/config/test.exs
	index 9afb2763a..1e8168548 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,197 +1,195 @@
	import Config

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

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

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

	config :pleroma, :auth, oauth_consumer_strategies: []

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

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

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

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

	config :pleroma, :activitypub, sign_object_fetches: false, follow_handshake_timeout: 0

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	port: System.get_env("DB_PORT") \|\| "5432",
	pool: Ecto.Adapters.SQL.Sandbox,
	pool_size: System.schedulers_online() * 2,
	log: false

	config :pleroma, :dangerzone, override_repo_pool_size: true

	# Reduce hash rounds for testing
	config :pleroma, :password, iterations: 1

	config :tesla, adapter: Tesla.Mock

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

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

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

	config :pleroma, Oban, testing: :manual

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

	config :pleroma, :rate_limit, %{}

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

	config :pleroma, :http, send_user_agent: false

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

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

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

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

	config :pleroma, Pleroma.Gun, Pleroma.GunMock

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

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

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

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	config :pleroma, :pipeline,
	object_validator: Pleroma.Web.ActivityPub.ObjectValidatorMock,
	mrf: Pleroma.Web.ActivityPub.MRFMock,
	activity_pub: Pleroma.Web.ActivityPub.ActivityPubMock,
	side_effects: Pleroma.Web.ActivityPub.SideEffectsMock,
	federator: Pleroma.Web.FederatorMock,
	config: Pleroma.ConfigMock

	config :pleroma, :cachex, provider: Pleroma.CachexMock

	config :pleroma, Pleroma.Web.WebFinger, update_nickname_on_user_fetch: false

	config :pleroma, :side_effects,
	ap_streamer: Pleroma.Web.ActivityPub.ActivityPubMock,
	logger: Pleroma.LoggerMock

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch, url: "http://127.0.0.1:7700/", private_key: nil

	# Reduce recompilation time
	# https://dashbit.co/blog/speeding-up-re-compilation-of-elixir-projects
	config :phoenix, :plug_init_mode, :runtime

	config :pleroma, :config_impl, Pleroma.UnstubbedConfigMock

	config :pleroma, Pleroma.PromEx, disabled: true

	# Mox definitions. Only read during compile time.
	config :pleroma, Pleroma.User.Backup, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Uploaders.S3, ex_aws_impl: Pleroma.Uploaders.S3.ExAwsMock
	config :pleroma, Pleroma.Uploaders.S3, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Upload, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.ScheduledActivity, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.RichMedia.Helpers, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Uploaders.IPFS, config_impl: Pleroma.UnstubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSecurityPlug, config_impl: Pleroma.StaticStubbedConfigMock
	config :pleroma, Pleroma.Web.Plugs.HTTPSignaturePlug, config_impl: Pleroma.StaticStubbedConfigMock

	config :pleroma, Pleroma.Web.Plugs.HTTPSignaturePlug,
	http_signatures_impl: Pleroma.StubbedHTTPSignaturesMock

	peer_module =
	if String.to_integer(System.otp_release()) >= 25 do
	:peer
	else
	:slave
	end

	config :pleroma, Pleroma.Cluster, peer_module: peer_module

	config :pleroma, Pleroma.Application,
	background_migrators: false,
	internal_fetch: false,
	load_custom_modules: false,
	max_restarts: 100,
	streamer_registry: false,
	test_http_pools: true

	config :pleroma, Pleroma.Web.Streaming, sync_streaming: true

	-config :pleroma, Pleroma.Web.MastodonAPI.StatusView, sync_fetching: true
	-
	config :pleroma, Pleroma.Uploaders.Uploader, timeout: 1_000

	config :pleroma, Pleroma.Emoji.Loader, test_emoji: true

	config :pleroma, Pleroma.Web.RichMedia.Backfill, provider: Pleroma.Web.RichMedia.Backfill

	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	else
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 963658b1e..d9d7e516a 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,857 +1,850 @@
	# 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.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	- alias Pleroma.Config
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController
	alias Pleroma.Web.RichMedia.Card

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	defp fetch_rich_media_for_activities(activities) do
	Enum.each(activities, fn activity ->
	- fun = fn -> Card.get_by_activity(activity) end
	-
	- if Config.get([__MODULE__, :sync_fetching], false) do
	- fun.()
	- else
	- spawn(fun)
	- end
	+ Card.get_by_activity(activity)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_quoted_activities([]), do: %{}

	defp get_quoted_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["quoteUrl"] != "" && object.data["quoteUrl"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	import Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

	def render("index.json", opts) do
	reading_user = opts[:for]

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start prefetching rich media before doing anything else
	fetch_rich_media_for_activities(activities)
	replied_to_activities = get_replied_to_activities(activities)
	quoted_activities = get_quoted_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:quoted_activities, quoted_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(reblogged_parent_activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(activity.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(opts[:for], activity)
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	edited_at =
	with %{"updated" => updated} <- object.data,
	date <- Utils.to_masto_date(updated),
	true <- date != "" do
	date
	else
	_ ->
	nil
	end

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	history_len =
	1 +
	(Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> length())

	# See render("history.json", ...) for more details
	# Here the implicit index of the current content is 0
	chrono_order = history_len - 1

	quote_activity = get_quote(activity, opts)

	quote_id =
	case quote_activity do
	%Activity{id: id} -> id
	_ -> nil
	end

	quote_post =
	if visible_for_user?(quote_activity, opts[:for]) and opts[:show_quote] != false do
	quote_rendering_opts = Map.merge(opts, %{activity: quote_activity, show_quote: false})
	render("show.json", quote_rendering_opts)
	else
	nil
	end

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	card =
	case Card.get_by_activity(activity) do
	%Card{} = result -> render("card.json", result)
	_ -> nil
	end

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object
	\|> Object.get_emoji_reactions()
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && get_source_text(object.data["source"]),
	created_at: created_at,
	edited_at: edited_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	quote: quote_post,
	quote_id: quote_id,
	quote_url: object.data["quoteUrl"],
	quote_visible: visible_for_user?(quote_activity, opts[:for]),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at,
	quotes_count: object.data["quotesCount"] \|\| 0,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	hashtags = Object.hashtags(object)

	user = CommonAPI.get_user(activity.data["actor"])

	past_history =
	Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> Enum.map(&Map.put(&1, "id", object.data["id"]))
	\|> Enum.map(&%Object{data: &1, id: object.id})

	history =
	[object \| past_history]
	# Mastodon expects the original to be at the first
	\|> Enum.reverse()
	\|> Enum.with_index()
	\|> Enum.map(fn {object, chrono_order} ->
	%{
	# The history is prepended every time there is a new edit.
	# In chrono_order, the oldest item is always at 0, and so on.
	# The chrono_order is an invariant kept between edits.
	chrono_order: chrono_order,
	object: object
	}
	end)

	individual_opts =
	opts
	\|> Map.put(:as, :item)
	\|> Map.put(:user, user)
	\|> Map.put(:hashtags, hashtags)

	render_many(history, StatusView, "history_item.json", individual_opts)
	end

	def render(
	"history_item.json",
	%{
	activity: activity,
	user: user,
	item: %{object: object, chrono_order: chrono_order},
	hashtags: hashtags
	} = opts
	) do
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["updated"] \|\| object.data["published"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	%{
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	content: content_html,
	sensitive: sensitive,
	spoiler_text: summary,
	created_at: created_at,
	media_attachments: attachments,
	emojis: build_emojis(object.data["emoji"]),
	poll: render(PollView, "show.json", object: object, for: opts[:for])
	}
	end

	def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
	object = Object.normalize(activity, fetch: false)

	%{
	id: activity.id,
	text: get_source_text(Map.get(object.data, "source", "")),
	spoiler_text: Map.get(object.data, "summary", ""),
	content_type: get_source_content_type(object.data["source"])
	}
	end

	def render("card.json", %Card{fields: rich_media}) do
	page_url_data = URI.parse(rich_media["url"])

	page_url = page_url_data \|> to_string

	image_url = proxied_url(rich_media["image"], page_url_data)
	audio_url = proxied_url(rich_media["audio"], page_url_data)
	video_url = proxied_url(rich_media["video"], page_url_data)

	%{
	type: "link",
	provider_name: page_url_data.host,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url,
	image_description: rich_media["image:alt"] \|\| "",
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	pleroma: %{
	opengraph:
	rich_media
	\|> Maps.put_if_present("image", image_url)
	\|> Maps.put_if_present("audio", audio_url)
	\|> Maps.put_if_present("video", video_url)
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	attachment_id =
	with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
	{_, %Object{data: _object_data, id: object_id}} <-
	{:object, Object.get_by_ap_id(ap_id)} do
	to_string(object_id)
	else
	_ ->
	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
	to_string(attachment["id"] \|\| hash_id)
	end

	description =
	if attachment["summary"] do
	HTML.strip_tags(attachment["summary"])
	else
	attachment["name"]
	end

	name = if attachment["summary"], do: attachment["name"]

	pleroma =
	%{mime_type: media_type}
	\|> Maps.put_if_present(:name, name)

	%{
	id: attachment_id,
	url: href,
	remote_url: href,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: description,
	pleroma: pleroma,
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	\|> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_quote(activity, %{quoted_activities: quoted_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- quoted_activities[object.data["quoteUrl"]] do
	# For when a quote post is inside an Announce
	Activity.get_create_by_object_ap_id_with_object(object.data["quoteUrl"])
	end
	end

	def get_quote(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["quoteUrl"] && object.data["quoteUrl"] != "" do
	Activity.get_create_by_object_ap_id(object.data["quoteUrl"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags
	\|> Enum.filter(&is_binary/1)
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	do: %{name: name, website: url}

	defp build_application(_), do: nil

	# Workaround for Elixir issue #10771
	# Avoid applying URI.merge unless necessary
	# TODO: revert to always attempting URI.merge(image_url_data, page_url_data)
	# when Elixir 1.12 is the minimum supported version
	@spec build_image_url(struct() \| nil, struct()) :: String.t() \| nil
	defp build_image_url(
	%URI{scheme: image_scheme, host: image_host} = image_url_data,
	%URI{} = _page_url_data
	)
	when not is_nil(image_scheme) and not is_nil(image_host) do
	image_url_data \|> to_string
	end

	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp get_source_text(%{"content" => content} = _source) do
	content
	end

	defp get_source_text(source) when is_binary(source) do
	source
	end

	defp get_source_text(_) do
	""
	end

	defp get_source_content_type(%{"mediaType" => type} = _source) do
	type
	end

	defp get_source_content_type(_source) do
	Utils.get_content_type(nil)
	end

	defp proxied_url(url, page_url_data) do
	if is_binary(url) do
	build_image_url(URI.parse(url), page_url_data) \|> MediaProxy.url()
	else
	nil
	end
	end
	end
	diff --git a/lib/pleroma/web/rich_media/backfill.ex b/lib/pleroma/web/rich_media/backfill.ex
	index 4ec50e132..1d8cc87d4 100644
	--- a/lib/pleroma/web/rich_media/backfill.ex
	+++ b/lib/pleroma/web/rich_media/backfill.ex
	@@ -1,101 +1,74 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Backfill do
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Web.RichMedia.Parser
	alias Pleroma.Web.RichMedia.Parser.TTL
	- alias Pleroma.Workers.RichMediaExpirationWorker
	+ alias Pleroma.Workers.RichMediaWorker

	require Logger

	- @backfiller Pleroma.Config.get([__MODULE__, :provider], Pleroma.Web.RichMedia.Backfill.Task)
	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	- @max_attempts 3
	- @retry 5_000

	- def start(%{url: url} = args) when is_binary(url) do
	+ @spec run(map()) ::
	+ :ok \| {:error, {:invalid_metadata, any()} \| :body_too_large \| {:content, any()} \| any()}
	+ def run(%{"url" => url} = args) do
	url_hash = Card.url_to_hash(url)

	- args =
	- args
	- \|> Map.put(:attempt, 1)
	- \|> Map.put(:url_hash, url_hash)
	-
	- @backfiller.run(args)
	- end
	-
	- def run(%{url: url, url_hash: url_hash, attempt: attempt} = args)
	- when attempt <= @max_attempts do
	case Parser.parse(url) do
	{:ok, fields} ->
	{:ok, card} = Card.create(url, fields)

	maybe_schedule_expiration(url, fields)

	- if Map.has_key?(args, :activity_id) do
	+ with %{"activity_id" => activity_id} <- args,
	+ false <- is_nil(activity_id) do
	stream_update(args)
	end

	warm_cache(url_hash, card)

	{:error, {:invalid_metadata, fields}} ->
	Logger.debug("Rich media incomplete or invalid metadata for #{url}: #{inspect(fields)}")
	negative_cache(url_hash)

	{:error, :body_too_large} ->
	Logger.error("Rich media error for #{url}: :body_too_large")
	negative_cache(url_hash)

	{:error, {:content_type, type}} ->
	Logger.debug("Rich media error for #{url}: :content_type is #{type}")
	negative_cache(url_hash)

	e ->
	Logger.debug("Rich media error for #{url}: #{inspect(e)}")
	-
	- :timer.sleep(@retry * attempt)
	-
	- run(%{args \| attempt: attempt + 1})
	+ {:error, e}
	end
	end

	- def run(%{url: url, url_hash: url_hash}) do
	- Logger.debug("Rich media failure for #{url}")
	-
	- negative_cache(url_hash, :timer.minutes(15))
	- end
	-
	defp maybe_schedule_expiration(url, fields) do
	case TTL.process(fields, url) do
	{:ok, ttl} when is_number(ttl) ->
	timestamp = DateTime.from_unix!(ttl)

	- RichMediaExpirationWorker.new(%{"url" => url}, scheduled_at: timestamp)
	+ RichMediaWorker.new(%{"op" => "expire", "url" => url}, scheduled_at: timestamp)
	\|> Oban.insert()

	_ ->
	:ok
	end
	end

	- defp stream_update(%{activity_id: activity_id}) do
	+ defp stream_update(%{"activity_id" => activity_id}) do
	Pleroma.Activity.get_by_id(activity_id)
	\|> Pleroma.Activity.normalize()
	\|> Pleroma.Web.ActivityPub.ActivityPub.stream_out()
	end

	defp warm_cache(key, val), do: @cachex.put(:rich_media_cache, key, val)
	- defp negative_cache(key, ttl \\ nil), do: @cachex.put(:rich_media_cache, key, nil, ttl: ttl)
	-end

	-defmodule Pleroma.Web.RichMedia.Backfill.Task do
	- alias Pleroma.Web.RichMedia.Backfill
	-
	- def run(args) do
	- Task.Supervisor.start_child(Pleroma.TaskSupervisor, Backfill, :run, [args],
	- name: {:global, {:rich_media, args.url_hash}}
	- )
	- end
	+ defp negative_cache(key, ttl \\ :timer.minutes(15)),
	+ do: @cachex.put(:rich_media_cache, key, nil, ttl: ttl)
	end
	diff --git a/lib/pleroma/web/rich_media/card.ex b/lib/pleroma/web/rich_media/card.ex
	index 040066f36..72ff5e791 100644
	--- a/lib/pleroma/web/rich_media/card.ex
	+++ b/lib/pleroma/web/rich_media/card.ex
	@@ -1,162 +1,163 @@
	defmodule Pleroma.Web.RichMedia.Card do
	use Ecto.Schema
	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	- alias Pleroma.Web.RichMedia.Backfill
	alias Pleroma.Web.RichMedia.Parser
	+ alias Pleroma.Workers.RichMediaWorker

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	@config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	@type t :: %__MODULE__{}

	schema "rich_media_card" do
	field(:url_hash, :binary)
	field(:fields, :map)

	timestamps()
	end

	@doc false
	def changeset(card, attrs) do
	card
	\|> cast(attrs, [:url_hash, :fields])
	\|> validate_required([:url_hash, :fields])
	\|> unique_constraint(:url_hash)
	end

	@spec create(String.t(), map()) :: {:ok, t()}
	def create(url, fields) do
	url_hash = url_to_hash(url)

	fields = Map.put_new(fields, "url", url)

	%__MODULE__{}
	\|> changeset(%{url_hash: url_hash, fields: fields})
	\|> Repo.insert(on_conflict: {:replace, [:fields]}, conflict_target: :url_hash)
	end

	@spec delete(String.t()) :: {:ok, Ecto.Schema.t()} \| {:error, Ecto.Changeset.t()} \| :ok
	def delete(url) do
	url_hash = url_to_hash(url)
	@cachex.del(:rich_media_cache, url_hash)

	case get_by_url(url) do
	%__MODULE__{} = card -> Repo.delete(card)
	nil -> :ok
	end
	end

	@spec get_by_url(String.t() \| nil) :: t() \| nil \| :error
	def get_by_url(url) when is_binary(url) do
	if @config_impl.get([:rich_media, :enabled]) do
	url_hash = url_to_hash(url)

	@cachex.fetch!(:rich_media_cache, url_hash, fn _ ->
	result =
	__MODULE__
	\|> where(url_hash: ^url_hash)
	\|> Repo.one()

	case result do
	%__MODULE__{} = card -> {:commit, card}
	_ -> {:ignore, nil}
	end
	end)
	else
	:error
	end
	end

	def get_by_url(nil), do: nil

	- @spec get_or_backfill_by_url(String.t(), map()) :: t() \| nil
	- def get_or_backfill_by_url(url, backfill_opts \\ %{}) do
	+ @spec get_or_backfill_by_url(String.t(), keyword()) :: t() \| nil
	+ def get_or_backfill_by_url(url, opts \\ []) do
	if @config_impl.get([:rich_media, :enabled]) do
	case get_by_url(url) do
	%__MODULE__{} = card ->
	card

	nil ->
	- backfill_opts = Map.put(backfill_opts, :url, url)
	+ activity_id = Keyword.get(opts, :activity, nil)

	- Backfill.start(backfill_opts)
	+ RichMediaWorker.new(%{"op" => "backfill", "url" => url, "activity_id" => activity_id})
	+ \|> Oban.insert()

	nil

	:error ->
	nil
	end
	else
	nil
	end
	end

	@spec get_by_object(Object.t()) :: t() \| nil \| :error
	def get_by_object(object) do
	case HTML.extract_first_external_url_from_object(object) do
	nil -> nil
	url -> get_or_backfill_by_url(url)
	end
	end

	@spec get_by_activity(Activity.t()) :: t() \| nil \| :error
	# Fake/Draft activity
	def get_by_activity(%Activity{id: "pleroma:fakeid"} = activity) do
	with {_, true} <- {:config, @config_impl.get([:rich_media, :enabled])},
	%Object{} = object <- Object.normalize(activity, fetch: false),
	url when not is_nil(url) <- HTML.extract_first_external_url_from_object(object) do
	case get_by_url(url) do
	# Cache hit
	%__MODULE__{} = card ->
	card

	# Cache miss, but fetch for rendering the Draft
	_ ->
	with {:ok, fields} <- Parser.parse(url),
	{:ok, card} <- create(url, fields) do
	card
	else
	_ -> nil
	end
	end
	else
	_ ->
	nil
	end
	end

	def get_by_activity(activity) do
	with %Object{} = object <- Object.normalize(activity, fetch: false),
	{_, nil} <- {:cached, get_cached_url(object, activity.id)} do
	nil
	else
	{:cached, url} ->
	- get_or_backfill_by_url(url, %{activity_id: activity.id})
	+ get_or_backfill_by_url(url, activity_id: activity.id)

	_ ->
	:error
	end
	end

	@spec url_to_hash(String.t()) :: String.t()
	def url_to_hash(url) do
	:crypto.hash(:sha256, url) \|> Base.encode16(case: :lower)
	end

	defp get_cached_url(object, activity_id) do
	key = "URL\|#{activity_id}"

	@cachex.fetch!(:scrubber_cache, key, fn _ ->
	url = HTML.extract_first_external_url_from_object(object)
	Activity.HTML.add_cache_key_for(activity_id, key)

	{:commit, url}
	end)
	end
	end
	diff --git a/lib/pleroma/workers/rich_media_expiration_worker.ex b/lib/pleroma/workers/rich_media_expiration_worker.ex
	deleted file mode 100644
	index 0b74687cf..000000000
	--- a/lib/pleroma/workers/rich_media_expiration_worker.ex
	+++ /dev/null
	@@ -1,15 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Workers.RichMediaExpirationWorker do
	- alias Pleroma.Web.RichMedia.Card
	-
	- use Oban.Worker,
	- queue: :background
	-
	- @impl Oban.Worker
	- def perform(%Job{args: %{"url" => url} = _args}) do
	- Card.delete(url)
	- end
	-end
	diff --git a/lib/pleroma/workers/rich_media_worker.ex b/lib/pleroma/workers/rich_media_worker.ex
	new file mode 100644
	index 000000000..f18ac658a
	--- /dev/null
	+++ b/lib/pleroma/workers/rich_media_worker.ex
	@@ -0,0 +1,19 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Workers.RichMediaWorker do
	+ alias Pleroma.Web.RichMedia.Backfill
	+ alias Pleroma.Web.RichMedia.Card
	+
	+ use Oban.Worker, queue: :background, max_attempts: 3, unique: [period: 300]
	+
	+ @impl Oban.Worker
	+ def perform(%Job{args: %{"op" => "expire", "url" => url} = _args}) do
	+ Card.delete(url)
	+ end
	+
	+ def perform(%Job{args: %{"op" => "backfill", "url" => _url} = args}) do
	+ Backfill.run(args)
	+ end
	+end
	diff --git a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	index f17add774..c78c03aba 100644
	--- a/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	+++ b/test/pleroma/web/pleroma_api/views/chat_message_reference_view_test.exs
	@@ -1,87 +1,90 @@
	# 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.ChatMessageReferenceViewTest do
	alias Pleroma.NullCache
	use Pleroma.DataCase, async: true

	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView

	import Mox
	import Pleroma.Factory

	setup do: clear_config([:rich_media, :enabled], true)

	test "it displays a chat message" do
	user = insert(:user)
	recipient = insert(:user)

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

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

	{:ok, upload} = ActivityPub.upload(file, actor: recipient.ap_id)

	{:ok, activity} =
	CommonAPI.post_chat_message(user, recipient, "kippis :firefox:", idempotency_key: "123")

	chat = Chat.get(user.id, recipient.ap_id)

	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	id = cm_ref.id

	Pleroma.CachexMock
	\|> stub(:get, fn
	:chat_message_id_idempotency_key_cache, ^id -> {:ok, "123"}
	cache, key -> NullCache.get(cache, key)
	end)
	\|> stub(:fetch, fn :rich_media_cache, _, _ -> {:ok, {:ok, %{}}} end)

	chat_message = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message[:id] == cm_ref.id
	assert chat_message[:content] == "kippis :firefox:"
	assert chat_message[:account_id] == user.id
	assert chat_message[:chat_id]
	assert chat_message[:created_at]
	assert chat_message[:unread] == false
	assert match?([%{shortcode: "firefox"}], chat_message[:emojis])
	assert chat_message[:idempotency_key] == "123"

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

	{:ok, activity} =
	CommonAPI.post_chat_message(recipient, user, "gkgkgk https://example.com/ogp",
	media_id: upload.id
	)

	+ ObanHelpers.perform_all()
	+
	object = Object.normalize(activity, fetch: false)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	chat_message_two = MessageReferenceView.render("show.json", chat_message_reference: cm_ref)

	assert chat_message_two[:id] == cm_ref.id
	assert chat_message_two[:content] == object.data["content"]
	assert chat_message_two[:account_id] == recipient.id
	assert chat_message_two[:chat_id] == chat_message[:chat_id]
	assert chat_message_two[:attachment]
	assert chat_message_two[:unread] == true
	assert chat_message_two[:card]
	end
	end
	diff --git a/test/pleroma/web/rich_media/card_test.exs b/test/pleroma/web/rich_media/card_test.exs
	index 516ac9951..c76df99e2 100644
	--- a/test/pleroma/web/rich_media/card_test.exs
	+++ b/test/pleroma/web/rich_media/card_test.exs
	@@ -1,71 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.CardTest do
	use Pleroma.DataCase, async: true

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.RichMedia.Card

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

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

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

	:ok
	end

	setup do: clear_config([:rich_media, :enabled], true)

	test "crawls URL in activity" do
	user = insert(:user)

	url = "https://example.com/ogp"
	url_hash = Card.url_to_hash(url)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "[test](#{url})",
	content_type: "text/markdown"
	})

	+ ObanHelpers.perform_all()
	+
	assert %Card{url_hash: ^url_hash, fields: _} = Card.get_by_activity(activity)
	end

	test "recrawls URLs on status edits/updates" do
	original_url = "https://google.com/"
	original_url_hash = Card.url_to_hash(original_url)
	updated_url = "https://yahoo.com/"
	updated_url_hash = Card.url_to_hash(updated_url)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "I like this site #{original_url}"})

	# Force a backfill
	Card.get_by_activity(activity)
	+ ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^original_url_hash, fields: _},
	Card.get_by_activity(activity)
	)

	{:ok, _} = CommonAPI.update(user, activity, %{status: "I like this site #{updated_url}"})

	activity = Pleroma.Activity.get_by_id(activity.id)

	# Force a backfill
	Card.get_by_activity(activity)
	+ ObanHelpers.perform_all()

	assert match?(
	%Card{url_hash: ^updated_url_hash, fields: _},
	Card.get_by_activity(activity)
	)
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	index cc28aa7f3..e02dd437a 100644
	--- a/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	+++ b/test/pleroma/web/rich_media/parser/ttl/aws_signed_url_test.exs
	@@ -1,105 +1,116 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrlTest do
	use Pleroma.DataCase, async: false
	- use Oban.Testing, repo: Pleroma.Repo
	+ use Oban.Testing, repo: Pleroma.Repo, testing: :inline

	import Mox

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.RichMedia.Card
	alias Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl

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

	clear_config([:rich_media, :enabled], true)

	:ok
	end

	test "s3 signed url is parsed correct for expiration time" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	expire_time =
	Timex.parse!(timestamp, "{ISO:Basic:Z}") \|> Timex.to_unix() \|> Kernel.+(valid_till)

	assert expire_time == Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl.ttl(metadata, url)
	end

	test "s3 signed url is parsed and correct ttl is set for rich media" do
	url = "https://pleroma.social/amz"

	{:ok, timestamp} =
	Timex.now()
	\|> DateTime.truncate(:second)
	\|> Timex.format("{ISO:Basic:Z}")

	# in seconds
	valid_till = 30

	metadata = construct_metadata(timestamp, valid_till, url)

	body = """
	<meta name="twitter:card" content="Pleroma" />
	<meta name="twitter:site" content="Pleroma" />
	<meta name="twitter:title" content="Pleroma" />
	<meta name="twitter:description" content="Pleroma" />
	<meta name="twitter:image" content="#{Map.get(metadata, "image")}" />
	"""

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^url
	} ->
	%Tesla.Env{status: 200, body: body}

	%{method: :head} ->
	%Tesla.Env{status: 200}
	end)

	Card.get_or_backfill_by_url(url)

	- assert_enqueued(worker: Pleroma.Workers.RichMediaExpirationWorker, args: %{"url" => url})
	+ # Find the backfill job
	+ expected_job =
	+ [
	+ worker: "Pleroma.Workers.RichMediaWorker",
	+ args: %{"op" => "backfill", "url" => url}
	+ ]

	- [%Oban.Job{scheduled_at: scheduled_at}] = all_enqueued()
	+ assert_enqueued(expected_job)
	+
	+ # Run it manually
	+ ObanHelpers.perform_all()
	+
	+ [%Oban.Job{scheduled_at: scheduled_at} \| _] = all_enqueued()

	timestamp_dt = Timex.parse!(timestamp, "{ISO:Basic:Z}")

	assert DateTime.diff(scheduled_at, timestamp_dt) == valid_till
	end

	test "AWS URL for an image without expiration works" do
	og_data = %{"image" => "https://amazonaws.com/image.png"}

	assert is_nil(AwsSignedUrl.ttl(og_data, ""))
	end

	defp construct_s3_url(timestamp, valid_till) do
	"https://pleroma.s3.ap-southeast-1.amazonaws.com/sachin%20%281%29%20_a%20-%25%2Aasdasd%20BNN%20bnnn%20.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIBLWWK6RGDQXDLJQ%2F20190716%2Fap-southeast-1%2Fs3%2Faws4_request&X-Amz-Date=#{timestamp}&X-Amz-Expires=#{valid_till}&X-Amz-Signature=04ffd6b98634f4b1bbabc62e0fac4879093cd54a6eed24fe8eb38e8369526bbf&X-Amz-SignedHeaders=host"
	end

	defp construct_metadata(timestamp, valid_till, url) do
	%{
	"image" => construct_s3_url(timestamp, valid_till),
	"site" => "Pleroma",
	"title" => "Pleroma",
	"description" => "Pleroma",
	"url" => url
	}
	end
	end
	diff --git a/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs b/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	index 770968d47..6805e786d 100644
	--- a/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	+++ b/test/pleroma/web/rich_media/parser/ttl/opengraph_test.exs
	@@ -1,41 +1,57 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RichMedia.Parser.TTL.OpengraphTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mox

	+ alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.RichMedia.Card

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

	clear_config([:rich_media, :enabled], true)

	:ok
	end

	test "OpenGraph TTL value is honored" do
	url = "https://reddit.com/r/somepost"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^url
	} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/reddit.html")}

	%{method: :head} ->
	%Tesla.Env{status: 200}
	end)

	Card.get_or_backfill_by_url(url)

	- assert_enqueued(worker: Pleroma.Workers.RichMediaExpirationWorker, args: %{"url" => url})
	+ # Find the backfill job
	+ expected_job =
	+ [
	+ worker: "Pleroma.Workers.RichMediaWorker",
	+ args: %{"op" => "backfill", "url" => url}
	+ ]
	+
	+ assert_enqueued(expected_job)
	+
	+ # Run it manually
	+ ObanHelpers.perform_all()
	+
	+ assert_enqueued(
	+ worker: Pleroma.Workers.RichMediaWorker,
	+ args: %{"op" => "expire", "url" => url}
	+ )
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 9:28 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798682
Default Alt Text: (71 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions