No OneTemporary
Actions

Size

702 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index b331ea83c..888d24ddc 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,609 +1,610 @@
	# Changelog
	All notable changes to this project will be documented in this file.

	The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

	## [unreleased]
	### Changed
	- Breaking: BBCode and Markdown formatters will no longer return any `\n` and only use `<br/>` for newlines

	### Removed
	- Breaking: removed `with_move` parameter from notifications timeline.

	### Added
	- NodeInfo: `pleroma:api/v1/notifications:include_types_filter` to the `features` list.
	+- NodeInfo: `pleroma_emoji_reactions` to the `features` list.
	- Configuration: `:restrict_unauthenticated` setting, restrict access for unauthenticated users to timelines (public and federate), user profiles and statuses.
	- New HTTP adapter [gun](https://github.com/ninenines/gun). Gun adapter requires minimum OTP version of 22.2 otherwise Pleroma won’t start. For hackney OTP update is not required.
	<details>
	<summary>API Changes</summary>
	- Mastodon API: Support for `include_types` in `/api/v1/notifications`.
	</details>

	## [2.0.0] - 2019-03-08
	### Security
	- Mastodon API: Fix being able to request enourmous amount of statuses in timelines leading to DoS. Now limited to 40 per request.

	### Removed
	- Breaking: Removed 1.0+ deprecated configurations `Pleroma.Upload, :strip_exif` and `:instance, :dedupe_media`
	- Breaking: OStatus protocol support
	- Breaking: MDII uploader
	- Breaking: Using third party engines for user recommendation
	<details>
	<summary>API Changes</summary>
	- Breaking: AdminAPI: migrate_from_db endpoint
	</details>

	### Changed
	- Breaking: Pleroma won't start if it detects unapplied migrations
	- Breaking: Elixir >=1.8 is now required (was >= 1.7)
	- Breaking: `Pleroma.Plugs.RemoteIp` and `:rate_limiter` enabled by default. Please ensure your reverse proxy forwards the real IP!
	- Breaking: attachment links (`config :pleroma, :instance, no_attachment_links` and `config :pleroma, Pleroma.Upload, link_name`) disabled by default
	- Breaking: OAuth: defaulted `[:auth, :enforce_oauth_admin_scope_usage]` setting to `true` which demands `admin` OAuth scope to perform admin actions (in addition to `is_admin` flag on User); make sure to use bundled or newer versions of AdminFE & PleromaFE to access admin / moderator features.
	- Breaking: Dynamic configuration has been rearchitected. The `:pleroma, :instance, dynamic_configuration` setting has been replaced with `config :pleroma, configurable_from_database`. Please backup your configuration to a file and run the migration task to ensure consistency with the new schema.
	- Breaking: `:instance, no_attachment_links` has been replaced with `:instance, attachment_links` which still takes a boolean value but doesn't use double negative language.
	- Replaced [pleroma_job_queue](https://git.pleroma.social/pleroma/pleroma_job_queue) and `Pleroma.Web.Federator.RetryQueue` with [Oban](https://github.com/sorentwo/oban) (see [`docs/config.md`](docs/config.md) on migrating customized worker / retry settings)
	- Introduced [quantum](https://github.com/quantum-elixir/quantum-core) job scheduler
	- Enabled `:instance, extended_nickname_format` in the default config
	- Add `rel="ugc"` to all links in statuses, to prevent SEO spam
	- Extract RSS functionality from OStatus
	- MRF (Simple Policy): Also use `:accept`/`:reject` on the actors rather than only their activities
	- OStatus: Extract RSS functionality
	- Deprecated `User.Info` embedded schema (fields moved to `User`)
	- Store status data inside Flag activity
	- Deprecated (reorganized as `UserRelationship` entity) User fields with user AP IDs (`blocks`, `mutes`, `muted_reblogs`, `muted_notifications`, `subscribers`).
	- Rate limiter is now disabled for localhost/socket (unless remoteip plug is enabled)
	- Logger: default log level changed from `warn` to `info`.
	- Config mix task `migrate_to_db` truncates `config` table before migrating the config file.
	- Allow account registration without an email
	- Default to `prepare: :unnamed` in the database configuration.
	- Instance stats are now loaded on startup instead of being empty until next hourly job.
	<details>
	<summary>API Changes</summary>

	- Breaking EmojiReactions: Change endpoints and responses to align with Mastodon
	- Breaking Admin API: `PATCH /api/pleroma/admin/users/:nickname/force_password_reset` is now `PATCH /api/pleroma/admin/users/force_password_reset` (accepts `nicknames` array in the request body)
	- Breaking: Admin API: Return link alongside with token on password reset
	- Breaking: Admin API: `PUT /api/pleroma/admin/reports/:id` is now `PATCH /api/pleroma/admin/reports`, see admin_api.md for details
	- Breaking: `/api/pleroma/admin/users/invite_token` now uses `POST`, changed accepted params and returns full invite in json instead of only token string.
	- Breaking replying to reports is now "report notes", enpoint changed from `POST /api/pleroma/admin/reports/:id/respond` to `POST /api/pleroma/admin/reports/:id/notes`
	- Mastodon API: stopped sanitizing display names, field names and subject fields since they are supposed to be treated as plaintext
	- Admin API: Return `total` when querying for reports
	- Mastodon API: Return `pleroma.direct_conversation_id` when creating a direct message (`POST /api/v1/statuses`)
	- Admin API: Return link alongside with token on password reset
	- Admin API: Support authentication via `x-admin-token` HTTP header
	- Mastodon API: Add `pleroma.direct_conversation_id` to the status endpoint (`GET /api/v1/statuses/:id`)
	- Mastodon API: `pleroma.thread_muted` to the Status entity
	- Mastodon API: Mark the direct conversation as read for the author when they send a new direct message
	- Mastodon API, streaming: Add `pleroma.direct_conversation_id` to the `conversation` stream event payload.
	- Mastodon API: Add `pleroma.unread_count` to the Marker entity
	- Admin API: Render whole status in grouped reports
	- Mastodon API: User timelines will now respect blocks, unless you are getting the user timeline of somebody you blocked (which would be empty otherwise).
	- Mastodon API: Favoriting / Repeating a post multiple times will now return the identical response every time. Before, executing that action twice would return an error ("already favorited") on the second try.
	- Mastodon API: Limit timeline requests to 3 per timeline per 500ms per user/ip by default.
	- Admin API: `PATCH /api/pleroma/admin/users/:nickname/credentials` and `GET /api/pleroma/admin/users/:nickname/credentials`
	</details>

	### Added
	- `:chat_limit` option to limit chat characters.
	- `cleanup_attachments` option to remove attachments along with statuses. Does not affect duplicate files and attachments without status. Enabling this will increase load to database when deleting statuses on larger instances.
	- Refreshing poll results for remote polls
	- Authentication: Added rate limit for password-authorized actions / login existence checks
	- Static Frontend: Add the ability to render user profiles and notices server-side without requiring JS app.
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mix task to list all users (`mix pleroma.user list`)
	- Mix task to send a test email (`mix pleroma.email test`)
	- Support for `X-Forwarded-For` and similar HTTP headers which used by reverse proxies to pass a real user IP address to the backend. Must not be enabled unless your instance is behind at least one reverse proxy (such as Nginx, Apache HTTPD or Varnish Cache).
	- MRF: New module which handles incoming posts based on their age. By default, all incoming posts that are older than 2 days will be unlisted and not shown to their followers.
	- User notification settings: Add `privacy_option` option.
	- Support for custom Elixir modules (such as MRF policies)
	- User settings: Add _This account is a_ option.
	- A new users admin digest email
	- OAuth: admin scopes support (relevant setting: `[:auth, :enforce_oauth_admin_scope_usage]`).
	- Add an option `authorized_fetch_mode` to require HTTP signatures for AP fetches.
	- ActivityPub: support for `replies` collection (output for outgoing federation & fetching on incoming federation).
	- Mix task to refresh counter cache (`mix pleroma.refresh_counter_cache`)
	<details>
	<summary>API Changes</summary>

	- Job queue stats to the healthcheck page
	- Admin API: Add ability to fetch reports, grouped by status `GET /api/pleroma/admin/grouped_reports`
	- Admin API: Add ability to require password reset
	- Mastodon API: Account entities now include `follow_requests_count` (planned Mastodon 3.x addition)
	- Pleroma API: `GET /api/v1/pleroma/accounts/:id/scrobbles` to get a list of recently scrobbled items
	- Pleroma API: `POST /api/v1/pleroma/scrobble` to scrobble a media item
	- Mastodon API: Add `upload_limit`, `avatar_upload_limit`, `background_upload_limit`, and `banner_upload_limit` to `/api/v1/instance`
	- Mastodon API: Add `pleroma.unread_conversation_count` to the Account entity
	- OAuth: support for hierarchical permissions / [Mastodon 2.4.3 OAuth permissions](https://docs.joinmastodon.org/api/permissions/)
	- Metadata Link: Atom syndication Feed
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mastodon API: Add `exclude_visibilities` parameter to the timeline and notification endpoints
	- Admin API: `/users/:nickname/toggle_activation` endpoint is now deprecated in favor of: `/users/activate`, `/users/deactivate`, both accept `nicknames` array
	- Admin API: Multiple endpoints now require `nicknames` array, instead of singe `nickname`:
	- `POST/DELETE /api/pleroma/admin/users/:nickname/permission_group/:permission_group` are deprecated in favor of: `POST/DELETE /api/pleroma/admin/users/permission_group/:permission_group`
	- `DELETE /api/pleroma/admin/users` (`nickname` query param or `nickname` sent in JSON body) is deprecated in favor of: `DELETE /api/pleroma/admin/users` (`nicknames` query array param or `nicknames` sent in JSON body)
	- Admin API: Add `GET /api/pleroma/admin/relay` endpoint - lists all followed relays
	- Pleroma API: `POST /api/v1/pleroma/conversations/read` to mark all conversations as read
	- ActivityPub: Support `Move` activities
	- Mastodon API: Add `/api/v1/markers` for managing timeline read markers
	- Mastodon API: Add the `recipients` parameter to `GET /api/v1/conversations`
	- Configuration: `feed` option for user atom feed.
	- Pleroma API: Add Emoji reactions
	- Admin API: Add `/api/pleroma/admin/instances/:instance/statuses` - lists all statuses from a given instance
	- Admin API: Add `/api/pleroma/admin/users/:nickname/statuses` - lists all statuses from a given user
	- Admin API: `PATCH /api/pleroma/users/confirm_email` to confirm email for multiple users, `PATCH /api/pleroma/users/resend_confirmation_email` to resend confirmation email for multiple users
	- ActivityPub: Configurable `type` field of the actors.
	- Mastodon API: `/api/v1/accounts/:id` has `source/pleroma/actor_type` field.
	- Mastodon API: `/api/v1/update_credentials` accepts `actor_type` field.
	- Captcha: Support native provider
	- Captcha: Enable by default
	- Mastodon API: Add support for `account_id` param to filter notifications by the account
	- Mastodon API: Add `emoji_reactions` property to Statuses
	- Mastodon API: Change emoji reaction reply format
	- Notifications: Added `pleroma:emoji_reaction` notification type
	- Mastodon API: Change emoji reaction reply format once more
	- Configuration: `feed.logo` option for tag feed.
	- Tag feed: `/tags/:tag.rss` - list public statuses by hashtag.
	- Mastodon API: Add `reacted` property to `emoji_reactions`
	- Pleroma API: Add reactions for a single emoji.
	- ActivityPub: `[:activitypub, :note_replies_output_limit]` setting sets the number of note self-replies to output on outgoing federation.
	- Admin API: `GET /api/pleroma/admin/stats` to get status count by visibility scope
	- Admin API: `GET /api/pleroma/admin/statuses` - list all statuses (accepts `godmode` and `local_only`)
	</details>

	### Fixed
	- Report emails now include functional links to profiles of remote user accounts
	- Not being able to log in to some third-party apps when logged in to MastoFE
	- MRF: `Delete` activities being exempt from MRF policies
	- OTP releases: Not being able to configure OAuth expired token cleanup interval
	- OTP releases: Not being able to configure HTML sanitization policy
	- OTP releases: Not being able to change upload limit (again)
	- Favorites timeline now ordered by favorite date instead of post date
	- Support for cancellation of a follow request
	<details>
	<summary>API Changes</summary>

	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- AdminAPI: If some status received reports both in the "new" format and "old" format it was considered reports on two different statuses (in the context of grouped reports)
	- Admin API: Error when trying to update reports in the "old" format
	- Mastodon API: Marking a conversation as read (`POST /api/v1/conversations/:id/read`) now no longer brings it to the top in the user's direct conversation list
	</details>

	## [1.1.9] - 2020-02-10
	### Fixed
	- OTP: Inability to set the upload limit (again)
	- Not being able to pin polls
	- Streaming API: incorrect handling of reblog mutes
	- Rejecting the user when field length limit is exceeded
	- OpenGraph provider: html entities in descriptions

	## [1.1.8] - 2020-01-10
	### Fixed
	- Captcha generation issues
	- Returned Kocaptcha endpoint to configuration
	- Captcha validity is now 5 minutes

	## [1.1.7] - 2019-12-13
	### Fixed
	- OTP: Inability to set the upload limit
	- OTP: Inability to override node name/distribution type to run 2 Pleroma instances on the same machine

	### Added
	- Integrated captcha provider

	### Changed
	- Captcha enabled by default
	- Default Captcha provider changed from `Pleroma.Captcha.Kocaptcha` to `Pleroma.Captcha.Native`
	- Better `Cache-Control` header for static content

	### Bundled Pleroma-FE Changes
	#### Added
	- Icons in the navigation panel

	#### Fixed
	- Improved support unauthenticated view of private instances

	#### Removed
	- Whitespace hack on empty post content

	## [1.1.6] - 2019-11-19
	### Fixed
	- Not being able to log into to third party apps when the browser is logged into mastofe
	- Email confirmation not being required even when enabled
	- Mastodon API: conversations API crashing when one status is malformed

	### Bundled Pleroma-FE Changes
	#### Added
	- About page
	- Meme arrows

	#### Fixed
	- Image modal not closing unless clicked outside of image
	- Attachment upload spinner not being centered
	- Showing follow counters being 0 when they are actually hidden

	## [1.1.5] - 2019-11-09
	### Fixed
	- Polls having different numbers in timelines/notifications/poll api endpoints due to cache desyncronization
	- Pleroma API: OAuth token endpoint not being found when ".json" suffix is appended

	### Changed
	- Frontend bundle updated to [044c9ad0](https://git.pleroma.social/pleroma/pleroma-fe/commit/044c9ad0562af059dd961d50961a3880fca9c642)

	## [1.1.4] - 2019-11-01
	### Fixed
	- Added a migration that fills up empty user.info fields to prevent breakage after previous unsafe migrations.
	- Failure to migrate from pre-1.0.0 versions
	- Mastodon API: Notification stream not including follow notifications

	## [1.1.3] - 2019-10-25
	### Fixed
	- Blocked users showing up in notifications collapsed as if they were muted
	- `pleroma_ctl` not working on Debian's default shell

	## [1.1.2] - 2019-10-18
	### Fixed
	- `pleroma_ctl` trying to connect to a running instance when generating the config, which of course doesn't exist.

	## [1.1.1] - 2019-10-18
	### Fixed
	- One of the migrations between 1.0.0 and 1.1.0 wiping user info of the relay user because of unexpected behavior of postgresql's `jsonb_set`, resulting in inability to post in the default configuration. If you were affected, please run the following query in postgres console, the relay user will be recreated automatically:
	```
	delete from users where ap_id = 'https://your.instance.hostname/relay';
	```
	- Bad user search matches

	## [1.1.0] - 2019-10-14
	Breaking: The stable branch has been changed from `master` to `stable`. If you want to keep using 1.0, the `release/1.0` branch will receive security updates for 6 months after 1.1 release.

	OTP Note: `pleroma_ctl` in 1.0 defaults to `master` and doesn't support specifying arbitrary branches, making `./pleroma_ctl update` fail. To fix this, fetch a version of `pleroma_ctl` from 1.1 using the command below and proceed with the update normally:
	```
	curl -Lo ./bin/pleroma_ctl 'https://git.pleroma.social/pleroma/pleroma/raw/develop/rel/files/bin/pleroma_ctl'
	```
	### Security
	- Mastodon API: respect post privacy in `/api/v1/statuses/:id/{favourited,reblogged}_by`

	### Removed
	- Breaking: GNU Social API with Qvitter extensions support
	- Emoji: Remove longfox emojis.
	- Remove `Reply-To` header from report emails for admins.
	- ActivityPub: The `/objects/:uuid/likes` endpoint.

	### Changed
	- Breaking: Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
	- Breaking: Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
	- Breaking: `/api/pleroma/notifications/read` is moved to `/api/v1/pleroma/notifications/read` and now supports `max_id` and responds with Mastodon API entities.
	- Configuration: added `config/description.exs`, from which `docs/config.md` is generated
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
	- NodeInfo: Return `mailerEnabled` in `metadata`
	- Mastodon API: Unsubscribe followers when they unfollow a user
	- Mastodon API: `pleroma.thread_muted` key in the Status entity
	- AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)
	- Improve digest email template
	– Pagination: (optional) return `total` alongside with `items` when paginating
	- The `Pleroma.FlakeId` module has been replaced with the `flake_id` library.

	### Fixed
	- Following from Osada
	- Favorites timeline doing database-intensive queries
	- Metadata rendering errors resulting in the entire page being inaccessible
	- `federation_incoming_replies_max_depth` option being ignored in certain cases
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Misskey's endless polls being unable to render
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
	- Mastodon API: Notifications endpoint crashing if one notification failed to render
	- Mastodon API: `exclude_replies` is correctly handled again.
	- Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Ensure the `account` field is not empty when rendering Notification entities.
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- Mastodon API: Blocks are now treated consistently between the Streaming API and the Timeline APIs
	- Rich Media: Parser failing when no TTL can be found by image TTL setters
	- Rich Media: The crawled URL is now spliced into the rich media data.
	- ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
	- ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
	- ActivityPub: Deactivated user deletion
	- ActivityPub: Fix `/users/:nickname/inbox` crashing without an authenticated user
	- MRF: fix ability to follow a relay when AntiFollowbotPolicy was enabled
	- ActivityPub: Correct addressing of Undo.
	- ActivityPub: Correct addressing of profile update activities.
	- ActivityPub: Polls are now refreshed when necessary.
	- Report emails now include functional links to profiles of remote user accounts
	- Existing user id not being preserved on insert conflict
	- Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
	- Report email not being sent to admins when the reporter is a remote user
	- Reverse Proxy limiting `max_body_length` was incorrectly defined and only checked `Content-Length` headers which may not be sufficient in some circumstances

	### Added
	- Expiring/ephemeral activites. All activities can have expires_at value set, which controls when they should be deleted automatically.
	- Mastodon API: in post_status, the expires_in parameter lets you set the number of seconds until an activity expires. It must be at least one hour.
	- Mastodon API: all status JSON responses contain a `pleroma.expires_at` item which states when an activity will expire. The value is only shown to the user who created the activity. To everyone else it's empty.
	- Configuration: `ActivityExpiration.enabled` controls whether expired activites will get deleted at the appropriate time. Enabled by default.
	- Conversations: Add Pleroma-specific conversation endpoints and status posting extensions. Run the `bump_all_conversations` task again to create the necessary data.
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	- MRF: Support for excluding specific domains from Transparency.
	- MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
	- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
	- Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
	- Mastodon API, extension: Ability to reset avatar, profile banner, and background
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
	- Mastodon API: Add support for muting/unmuting notifications
	- Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
	- Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
	- Mastodon API: Add `pleroma.deactivated` to the Account entity
	- Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
	- Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
	- Mastodon API: Improve support for the user profile custom fields
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Added an endpoint to get multiple statuses by IDs (`GET /api/v1/statuses/?ids[]=1&ids[]=2`)
	- Admin API: Return users' tags when querying reports
	- Admin API: Return avatar and display name when querying users
	- Admin API: Allow querying user by ID
	- Admin API: Added support for `tuples`.
	- Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
	- Configuration: `user_bio_length` and `user_name_length` options.
	- Addressable lists
	- Twitter API: added rate limit for `/api/account/password_reset` endpoint.
	- ActivityPub: Add an internal service actor for fetching ActivityPub objects.
	- ActivityPub: Optional signing of ActivityPub object fetches.
	- Admin API: Endpoint for fetching latest user's statuses
	- Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
	- Pleroma API: Email change endpoint.
	- Admin API: Added moderation log
	- Web response cache (currently, enabled for ActivityPub)
	- Reverse Proxy: Do not retry failed requests to limit pressure on the peer

	### Changed
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Admin API: changed json structure for saving config settings.
	- RichMedia: parsers and their order are configured in `rich_media` config.
	- RichMedia: add the rich media ttl based on image expiration time.

	## [1.0.7] - 2019-09-26
	### Fixed
	- Broken federation on Erlang 22 (previous versions of hackney http client were using an option that got deprecated)
	### Changed
	- ActivityPub: The first page in inboxes/outboxes is no longer embedded.

	## [1.0.6] - 2019-08-14
	### Fixed
	- MRF: fix use of unserializable keyword lists in describe() implementations
	- ActivityPub S2S: POST requests are now signed with `(request-target)` pseudo-header.

	## [1.0.5] - 2019-08-13
	### Fixed
	- Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
	- Mastodon API: `muted` in the Status entity, using author's account to determine if the thread was muted
	- Mastodon API: return the actual profile URL in the Account entity's `url` property when appropriate
	- Templates: properly style anchor tags
	- Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
	- Not being able to access the Mastodon FE login page on private instances
	- MRF: ensure that subdomain_match calls are case-insensitive
	- Fix internal server error when using the healthcheck API.

	### Added
	- Breaking: MRF describe API, which adds support for exposing configuration information about MRF policies to NodeInfo.
	Custom modules will need to be updated by adding, at the very least, `def describe, do: {:ok, %{}}` to the MRF policy modules.
	- Relays: Added a task to list relay subscriptions.
	- MRF: Support for filtering posts based on ActivityStreams vocabulary (`Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`)
	- MRF (Simple Policy): Support for wildcard domains.
	- Support for wildcard domains in user domain blocks setting.
	- Configuration: `quarantined_instances` support wildcard domains.
	- Mix Tasks: `mix pleroma.database fix_likes_collections`
	- Configuration: `federation_incoming_replies_max_depth` option

	### Removed
	- Federation: Remove `likes` from objects.
	- Breaking: ActivityPub: The `accept_blocks` configuration setting.

	## [1.0.4] - 2019-08-01
	### Fixed
	- Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag

	## [1.0.3] - 2019-07-31
	### Security
	- OStatus: eliminate the possibility of a protocol downgrade attack.
	- OStatus: prevent following locked accounts, bypassing the approval process.
	- TwitterAPI: use CommonAPI to handle remote follows instead of OStatus.

	## [1.0.2] - 2019-07-28
	### Fixed
	- Not being able to pin unlisted posts
	- Mastodon API: represent poll IDs as strings
	- MediaProxy: fix matching filenames
	- MediaProxy: fix filename encoding
	- Migrations: fix a sporadic migration failure
	- Metadata rendering errors resulting in the entire page being inaccessible
	- Federation/MediaProxy not working with instances that have wrong certificate order
	- ActivityPub S2S: remote user deletions now work the same as local user deletions.

	### Changed
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text

	## [1.0.1] - 2019-07-14
	### Security
	- OStatus: fix an object spoofing vulnerability.

	## [1.0.0] - 2019-06-29
	### Security
	- Mastodon API: Fix display names not being sanitized
	- Rich media: Do not crawl private IP ranges

	### Added
	- Digest email for inactive users
	- Add a generic settings store for frontends / clients to use.
	- Explicit addressing option for posting.
	- Optional SSH access mode. (Needs `erlang-ssh` package on some distributions).
	- [MongooseIM](https://github.com/esl/MongooseIM) http authentication support.
	- LDAP authentication
	- External OAuth provider authentication
	- Support for building a release using [`mix release`](https://hexdocs.pm/mix/master/Mix.Tasks.Release.html)
	- A [job queue](https://git.pleroma.social/pleroma/pleroma_job_queue) for federation, emails, web push, etc.
	- [Prometheus](https://prometheus.io/) metrics
	- Support for Mastodon's remote interaction
	- Mix Tasks: `mix pleroma.database bump_all_conversations`
	- Mix Tasks: `mix pleroma.database remove_embedded_objects`
	- Mix Tasks: `mix pleroma.database update_users_following_followers_counts`
	- Mix Tasks: `mix pleroma.user toggle_confirmed`
	- Mix Tasks: `mix pleroma.config migrate_to_db`
	- Mix Tasks: `mix pleroma.config migrate_from_db`
	- Federation: Support for `Question` and `Answer` objects
	- Federation: Support for reports
	- Configuration: `poll_limits` option
	- Configuration: `pack_extensions` option
	- Configuration: `safe_dm_mentions` option
	- Configuration: `link_name` option
	- Configuration: `fetch_initial_posts` option
	- Configuration: `notify_email` option
	- Configuration: Media proxy `whitelist` option
	- Configuration: `report_uri` option
	- Configuration: `email_notifications` option
	- Configuration: `limit_to_local_content` option
	- Pleroma API: User subscriptions
	- Pleroma API: Healthcheck endpoint
	- Pleroma API: `/api/v1/pleroma/mascot` per-user frontend mascot configuration endpoints
	- Admin API: Endpoints for listing/revoking invite tokens
	- Admin API: Endpoints for making users follow/unfollow each other
	- Admin API: added filters (role, tags, email, name) for users endpoint
	- Admin API: Endpoints for managing reports
	- Admin API: Endpoints for deleting and changing the scope of individual reported statuses
	- Admin API: Endpoints to view and change config settings.
	- AdminFE: initial release with basic user management accessible at /pleroma/admin/
	- Mastodon API: Add chat token to `verify_credentials` response
	- Mastodon API: Add background image setting to `update_credentials`
	- Mastodon API: [Scheduled statuses](https://docs.joinmastodon.org/api/rest/scheduled-statuses/)
	- Mastodon API: `/api/v1/notifications/destroy_multiple` (glitch-soc extension)
	- Mastodon API: `/api/v1/pleroma/accounts/:id/favourites` (API extension)
	- Mastodon API: [Reports](https://docs.joinmastodon.org/api/rest/reports/)
	- Mastodon API: `POST /api/v1/accounts` (account creation API)
	- Mastodon API: [Polls](https://docs.joinmastodon.org/api/rest/polls/)
	- ActivityPub C2S: OAuth endpoints
	- Metadata: RelMe provider
	- OAuth: added support for refresh tokens
	- Emoji packs and emoji pack manager
	- Object pruning (`mix pleroma.database prune_objects`)
	- OAuth: added job to clean expired access tokens
	- MRF: Support for rejecting reports from specific instances (`mrf_simple`)
	- MRF: Support for stripping avatars and banner images from specific instances (`mrf_simple`)
	- MRF: Support for running subchains.
	- Configuration: `skip_thread_containment` option
	- Configuration: `rate_limit` option. See `Pleroma.Plugs.RateLimiter` documentation for details.
	- MRF: Support for filtering out likely spam messages by rejecting posts from new users that contain links.
	- Configuration: `ignore_hosts` option
	- Configuration: `ignore_tld` option
	- Configuration: default syslog tag "Pleroma" is now lowercased to "pleroma"

	### Changed
	- Breaking: bind to 127.0.0.1 instead of 0.0.0.0 by default
	- Breaking: Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
	- Thread containment / test for complete visibility will be skipped by default.
	- Enforcement of OAuth scopes
	- Add multiple use/time expiring invite token
	- Restyled OAuth pages to fit with Pleroma's default theme
	- Link/mention/hashtag detection is now handled by [auto_linker](https://git.pleroma.social/pleroma/auto_linker)
	- NodeInfo: Return `safe_dm_mentions` feature flag
	- Federation: Expand the audience of delete activities to all recipients of the deleted object
	- Federation: Removed `inReplyToStatusId` from objects
	- Configuration: Dedupe enabled by default
	- Configuration: Default log level in `prod` environment is now set to `warn`
	- Configuration: Added `extra_cookie_attrs` for setting non-standard cookie attributes. Defaults to ["SameSite=Lax"] so that remote follows work.
	- Timelines: Messages involving people you have blocked will be excluded from the timeline in all cases instead of just repeats.
	- Admin API: Move the user related API to `api/pleroma/admin/users`
	- Admin API: `POST /api/pleroma/admin/users` will take list of users
	- Pleroma API: Support for emoji tags in `/api/pleroma/emoji` resulting in a breaking API change
	- Mastodon API: Support for `exclude_types`, `limit` and `min_id` in `/api/v1/notifications`
	- Mastodon API: Add `languages` and `registrations` to `/api/v1/instance`
	- Mastodon API: Provide plaintext versions of cw/content in the Status entity
	- Mastodon API: Add `pleroma.conversation_id`, `pleroma.in_reply_to_account_acct` fields to the Status entity
	- Mastodon API: Add `pleroma.tags`, `pleroma.relationship{}`, `pleroma.is_moderator`, `pleroma.is_admin`, `pleroma.confirmation_pending`, `pleroma.hide_followers`, `pleroma.hide_follows`, `pleroma.hide_favorites` fields to the User entity
	- Mastodon API: Add `pleroma.show_role`, `pleroma.no_rich_text` fields to the Source subentity
	- Mastodon API: Add support for updating `no_rich_text`, `hide_followers`, `hide_follows`, `hide_favorites`, `show_role` in `PATCH /api/v1/update_credentials`
	- Mastodon API: Add `pleroma.is_seen` to the Notification entity
	- Mastodon API: Add `pleroma.local` to the Status entity
	- Mastodon API: Add `preview` parameter to `POST /api/v1/statuses`
	- Mastodon API: Add `with_muted` parameter to timeline endpoints
	- Mastodon API: Actual reblog hiding instead of a dummy
	- Mastodon API: Remove attachment limit in the Status entity
	- Mastodon API: Added support max_id & since_id for bookmark timeline endpoints.
	- Deps: Updated Cowboy to 2.6
	- Deps: Updated Ecto to 3.0.7
	- Don't ship finmoji by default, they can be installed as an emoji pack
	- Hide deactivated users and their statuses
	- Posts which are marked sensitive or tagged nsfw no longer have link previews.
	- HTTP connection timeout is now set to 10 seconds.
	- Respond with a 404 Not implemented JSON error message when requested API is not implemented
	- Rich Media: crawl only https URLs.

	### Fixed
	- Follow requests don't get 'stuck' anymore.
	- Added an FTS index on objects. Running `vacuum analyze` and setting a larger `work_mem` is recommended.
	- Followers counter not being updated when a follower is blocked
	- Deactivated users being able to request an access token
	- Limit on request body in rich media/relme parsers being ignored resulting in a possible memory leak
	- Proper Twitter Card generation instead of a dummy
	- Deletions failing for users with a large number of posts
	- NodeInfo: Include admins in `staffAccounts`
	- ActivityPub: Crashing when requesting empty local user's outbox
	- Federation: Handling of objects without `summary` property
	- Federation: Add a language tag to activities as required by ActivityStreams 2.0
	- Federation: Do not federate avatar/banner if set to default allowing other servers/clients to use their defaults
	- Federation: Cope with missing or explicitly nulled address lists
	- Federation: Explicitly ensure activities addressed to `as:Public` become addressed to the followers collection
	- Federation: Better cope with actors which do not declare a followers collection and use `as:Public` with these semantics
	- Federation: Follow requests from remote users who have been blocked will be automatically rejected if appropriate
	- MediaProxy: Parse name from content disposition headers even for non-whitelisted types
	- MediaProxy: S3 link encoding
	- Rich Media: Reject any data which cannot be explicitly encoded into JSON
	- Pleroma API: Importing follows from Mastodon 2.8+
	- Twitter API: Exposing default scope, `no_rich_text` of the user to anyone
	- Twitter API: Returning the `role` object in user entity despite `show_role = false`
	- Mastodon API: `/api/v1/favourites` serving only public activities
	- Mastodon API: Reblogs having `in_reply_to_id` - `null` even when they are replies
	- Mastodon API: Streaming API broadcasting wrong activity id
	- Mastodon API: 500 errors when requesting a card for a private conversation
	- Mastodon API: Handling of `reblogs` in `/api/v1/accounts/:id/follow`
	- Mastodon API: Correct `reblogged`, `favourited`, and `bookmarked` values in the reblog status JSON
	- Mastodon API: Exposing default scope of the user to anyone
	- Mastodon API: Make `irreversible` field default to `false` [`POST /api/v1/filters`]
	- Mastodon API: Replace missing non-nullable Card attributes with empty strings
	- User-Agent is now sent correctly for all HTTP requests.
	- MRF: Simple policy now properly delists imported or relayed statuses

	## Removed
	- Configuration: `config :pleroma, :fe` in favor of the more flexible `config :pleroma, :frontend_configurations`

	## [0.9.99999] - 2019-05-31
	### Security
	- Mastodon API: Fix lists leaking private posts

	## [0.9.9999] - 2019-04-05
	### Security
	- Mastodon API: Fix content warnings skipping HTML sanitization

	## [0.9.999] - 2019-03-13
	Frontend changes only.
	### Added
	- Added floating action button for posting status on mobile
	### Changed
	- Changed user-settings icon to a pencil
	### Fixed
	- Keyboard shortcuts activating when typing a message
	- Gaps when scrolling down on a timeline after showing new

	## [0.9.99] - 2019-03-08
	### Changed
	- Update the frontend to the 0.9.99 tag
	### Fixed
	- Sign the date header in federation to fix Mastodon federation.

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/COPYING b/COPYING
	index 0aede0fba..3140c8038 100644
	--- a/COPYING
	+++ b/COPYING
	@@ -1,49 +1,49 @@
	-Unless otherwise stated this repository is copyright © 2017-2019
	+Unless otherwise stated this repository is copyright © 2017-2020
	Pleroma Authors <https://pleroma.social/>, and is distributed under
	The GNU Affero General Public License Version 3, you should have received a
	copy of the license file as AGPL-3.

	---

	The following files are copyright © 2019 shitposter.club, and are distributed
	under the Creative Commons Attribution-ShareAlike 4.0 International license,
	you should have received a copy of the license file as CC-BY-SA-4.0.

	priv/static/images/pleroma-fox-tan.png
	priv/static/images/pleroma-fox-tan-smol.png
	priv/static/images/pleroma-tan.png

	---

	The following files are copyright © 2019 shitposter.club, and are distributed
	under the Creative Commons Attribution 4.0 International license, you should
	have received a copy of the license file as CC-BY-4.0.

	priv/static/images/pleroma-fox-tan-shy.png

	---

	-The following files are copyright © 2017-2019 Pleroma Authors
	+The following files are copyright © 2017-2020 Pleroma Authors
	<https://pleroma.social/>, and are distributed under the Creative Commons
	Attribution-ShareAlike 4.0 International license, you should have received
	a copy of the license file as CC-BY-SA-4.0.

	priv/static/images/avi.png
	priv/static/images/banner.png
	priv/static/instance/thumbnail.jpeg

	---

	All photos published on Unsplash can be used for free. You can use them for
	commercial and noncommercial purposes. You do not need to ask permission from
	or provide credit to the photographer or Unsplash, although it is appreciated
	when possible.

	More precisely, Unsplash grants you an irrevocable, nonexclusive, worldwide
	copyright license to download, copy, modify, distribute, perform, and use
	photos from Unsplash for free, including for commercial purposes, without
	permission from or attributing the photographer or Unsplash. This license
	does not include the right to compile photos from Unsplash to replicate
	a similar or competing service.

	priv/static/images/city.jpg
	diff --git a/coveralls.json b/coveralls.json
	new file mode 100644
	index 000000000..75e845ade
	--- /dev/null
	+++ b/coveralls.json
	@@ -0,0 +1,6 @@
	+{
	+ "skip_files": [
	+ "test/support",
	+ "lib/mix/tasks/pleroma/benchmark.ex"
	+ ]
	+}
	\ No newline at end of file
	diff --git a/docs/API/differences_in_mastoapi_responses.md b/docs/API/differences_in_mastoapi_responses.md
	index 01be7787f..0a7520f9e 100644
	--- a/docs/API/differences_in_mastoapi_responses.md
	+++ b/docs/API/differences_in_mastoapi_responses.md
	@@ -1,194 +1,199 @@
	# Differences in Mastodon API responses from vanilla Mastodon

	A Pleroma instance can be identified by "<Mastodon version> (compatible; Pleroma <version>)" present in `version` field in response from `/api/v1/instance`

	## Flake IDs

	Pleroma uses 128-bit ids as opposed to Mastodon's 64 bits. However just like Mastodon's ids they are sortable strings

	## Attachment cap

	Some apps operate under the assumption that no more than 4 attachments can be returned or uploaded. Pleroma however does not enforce any limits on attachment count neither when returning the status object nor when posting.

	## Timelines

	Adding the parameter `with_muted=true` to the timeline queries will also return activities by muted (not by blocked!) users.
	Adding the parameter `exclude_visibilities` to the timeline queries will exclude the statuses with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`), e.g., `exclude_visibilities[]=direct&exclude_visibilities[]=private`.

	## Statuses

	- `visibility`: has an additional possible value `list`

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance
	- `conversation_id`: the ID of the AP context the status is associated with (if any)
	- `direct_conversation_id`: the ID of the Mastodon direct message conversation the status is associated with (if any)
	- `in_reply_to_account_acct`: the `acct` property of User entity for replied user (if any)
	- `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	- `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	- `expires_at`: a datetime (iso8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire
	- `thread_muted`: true if the thread the post belongs to is muted
	- `emoji_reactions`: A list with emoji / reaction maps. The format is `{name: "☕", count: 1, me: true}`. Contains no information about the reacting users, for that use the `/statuses/:id/reactions` endpoint.

	## Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	## Accounts

	The `id` parameter can also be the `nickname` of the user. This only works in these endpoints, not the deeper nested ones for following etc.

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/statuses`

	Has these additional fields under the `pleroma` object:

	- `tags`: Lists an array of tags for the user
	- `relationship{}`: Includes fields as documented for Mastodon API https://docs.joinmastodon.org/entities/relationship/
	- `is_moderator`: boolean, nullable, true if user is a moderator
	- `is_admin`: boolean, nullable, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated
	- `hide_followers`: boolean, true when the user has follower hiding enabled
	- `hide_follows`: boolean, true when the user has follow hiding enabled
	- `hide_followers_count`: boolean, true when the user has follower stat hiding enabled
	- `hide_follows_count`: boolean, true when the user has follow stat hiding enabled
	- `settings_store`: A generic map of settings for frontends. Opaque to the backend. Only returned in `verify_credentials` and `update_credentials`
	- `chat_token`: The token needed for Pleroma chat. Only returned in `verify_credentials`
	- `deactivated`: boolean, true when the user is deactivated
	- `allow_following_move`: boolean, true when the user allows automatically follow moved following accounts
	- `unread_conversation_count`: The count of unread conversations. Only returned to the account owner.

	### Source

	Has these additional fields under the `pleroma` object:

	- `show_role`: boolean, nullable, true when the user wants his role (e.g admin, moderator) to be shown
	- `no_rich_text` - boolean, nullable, true when html tags are stripped from all statuses requested from the API
	- `discoverable`: boolean, true when the user allows discovery of the account in search results and other services.
	- `actor_type`: string, the type of this account.

	## Conversations

	Has an additional field under the `pleroma` object:

	- `recipients`: The list of the recipients of this Conversation. These will be addressed when replying to this conversation.

	## GET `/api/v1/conversations`

	Accepts additional parameters:

	- `recipients`: Only return conversations with the given recipients (a list of user ids). Usage example: `GET /api/v1/conversations?recipients[]=1&recipients[]=2`

	## Account Search

	Behavior has changed:

	- `/api/v1/accounts/search`: Does not require authentication

	## Search (global)

	Unlisted posts are available in search results, they are considered to be public posts that shouldn't be shown in local/federated timeline.

	## Notifications

	Has these additional fields under the `pleroma` object:

	- `is_seen`: true if the notification was read by the user

	### Move Notification

	The `type` value is `move`. Has an additional field:

	- `target`: new account

	### EmojiReact Notification

	The `type` value is `pleroma:emoji_reaction`. Has these fields:

	- `emoji`: The used emoji
	- `account`: The account of the user who reacted
	- `status`: The status that was reacted on

	## GET `/api/v1/notifications`

	Accepts additional parameters:

	- `exclude_visibilities`: will exclude the notifications for activities with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`). Usage example: `GET /api/v1/notifications?exclude_visibilities[]=direct&exclude_visibilities[]=private`.
	- `include_types`: will include the notifications for activities with the given types. The parameter accepts an array of types (`mention`, `follow`, `reblog`, `favourite`, `move`, `pleroma:emoji_reaction`). Usage example: `GET /api/v1/notifications?include_types[]=mention&include_types[]=reblog`.

	## POST `/api/v1/statuses`

	Additional parameters can be added to the JSON body/Form data:

	- `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
	- `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
	- `to`: A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply.
	- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
	- `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.
	- `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`.

	## GET `/api/v1/statuses`

	An endpoint to get multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `GET /api/v1/statuses/?ids[]=1&ids[]=2`.

	Returns: array of Status.

	The maximum number of statuses is limited to 100 per request.

	## PATCH `/api/v1/update_credentials`

	Additional parameters can be added to the JSON body/Form data:

	- `no_rich_text` - if true, html tags are stripped from all statuses requested from the API
	- `hide_followers` - if true, user's followers will be hidden
	- `hide_follows` - if true, user's follows will be hidden
	- `hide_followers_count` - if true, user's follower count will be hidden
	- `hide_follows_count` - if true, user's follow count will be hidden
	- `hide_favorites` - if true, user's favorites timeline will be hidden
	- `show_role` - if true, user's role (e.g admin, moderator) will be exposed to anyone in the API
	- `default_scope` - the scope returned under `privacy` key in Source subentity
	- `pleroma_settings_store` - Opaque user settings to be saved on the backend.
	- `skip_thread_containment` - if true, skip filtering out broken threads
	- `allow_following_move` - if true, allows automatically follow moved following accounts
	- `pleroma_background_image` - sets the background image of the user.
	- `discoverable` - if true, discovery of this account in search results and other services is allowed.
	- `actor_type` - the type of this account.

	### Pleroma Settings Store
	+
	Pleroma has mechanism that allows frontends to save blobs of json for each user on the backend. This can be used to save frontend-specific settings for a user that the backend does not need to know about.

	The parameter should have a form of `{frontend_name: {...}}`, with `frontend_name` identifying your type of client, e.g. `pleroma_fe`. It will overwrite everything under this property, but will not overwrite other frontend's settings.

	This information is returned in the `verify_credentials` endpoint.

	## Authentication

	-*Pleroma supports refreshing tokens.
	+Pleroma supports refreshing tokens.

	`POST /oauth/token`
	-Post here request with grant_type=refresh_token to obtain new access token. Returns an access token.
	+
	+Post here request with `grant_type=refresh_token` to obtain new access token. Returns an access token.

	## Account Registration
	+
	`POST /api/v1/accounts`

	Has theses additional parameters (which are the same as in Pleroma-API):
	- * `fullname`: optional
	- * `bio`: optional
	- * `captcha_solution`: optional, contains provider-specific captcha solution,
	- * `captcha_token`: optional, contains provider-specific captcha token
	- * `token`: invite token required when the registerations aren't public.
	+
	+ `fullname`: optional
	+ `bio`: optional
	+ `captcha_solution`: optional, contains provider-specific captcha solution,
	+ `captcha_token`: optional, contains provider-specific captcha token
	+ `token`: invite token required when the registrations aren't public.
	+

	## Markers

	Has these additional fields under the `pleroma` object:

	- `unread_count`: contains number unread notifications
	diff --git a/docs/API/pleroma_api.md b/docs/API/pleroma_api.md
	index 12e63ef9f..90c43c356 100644
	--- a/docs/API/pleroma_api.md
	+++ b/docs/API/pleroma_api.md
	@@ -1,475 +1,475 @@
	# Pleroma API

	Requests that require it can be authenticated with [an OAuth token](https://tools.ietf.org/html/rfc6749), the `_pleroma_key` cookie, or [HTTP Basic Authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization).

	Request parameters can be passed via [query strings](https://en.wikipedia.org/wiki/Query_string) or as [form data](https://www.w3.org/TR/html401/interact/forms.html). Files must be uploaded as `multipart/form-data`.

	## `/api/pleroma/emoji`
	### Lists the custom emoji on that server.
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON
	* Example response:
	```json
	{
	"girlpower": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/girlpower-128.png"
	},
	"education": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/education-128.png"
	},
	"finnishlove": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/finnishlove-128.png"
	}
	}
	```
	* Note: Same data as Mastodon API’s `/api/v1/custom_emojis` but in a different format

	## `/api/pleroma/follow_import`
	### Imports your follows, for example from a Mastodon CSV file.
	* Method: `POST`
	* Authentication: required
	* Params:
	* `list`: STRING or FILE containing a whitespace-separated list of accounts to follow
	* Response: HTTP 200 on success, 500 on error
	* Note: Users that can't be followed are silently skipped.

	## `/api/pleroma/captcha`
	### Get a new captcha
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: Provider specific JSON, the only guaranteed parameter is `type`
	* Example response: `{"type": "kocaptcha", "token": "whatever", "url": "https://captcha.kotobank.ch/endpoint"}`

	## `/api/pleroma/delete_account`
	### Delete an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the deletion was successful, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/disable_account`
	### Disable an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the account was successfully disabled, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/admin/`…
	See [Admin-API](admin_api.md)

	## `/api/v1/pleroma/notifications/read`
	### Mark notifications as read
	* Method `POST`
	* Authentication: required
	* Params (mutually exclusive):
	* `id`: a single notification id to read
	* `max_id`: read all notifications up to this id
	* Response: Notification entity/Array of Notification entities that were read. In case of `max_id`, only the first 80 read notifications will be returned.

	## `/api/v1/pleroma/accounts/:id/subscribe`
	### Subscribe to receive notifications for all statuses posted by a user
	* Method `POST`
	* Authentication: required
	* Params:
	* `id`: account id to subscribe to
	* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"following": true,
	"followed_by": false,
	"blocking": false,
	"muting": false,
	"muting_notifications": false,
	"subscribing": true,
	"requested": false,
	"domain_blocking": false,
	"showing_reblogs": true,
	"endorsed": false
	}
	```

	## `/api/v1/pleroma/accounts/:id/unsubscribe`
	### Unsubscribe to stop receiving notifications from user statuses
	* Method `POST`
	* Authentication: required
	* Params:
	* `id`: account id to unsubscribe from
	* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"following": true,
	"followed_by": false,
	"blocking": false,
	"muting": false,
	"muting_notifications": false,
	"subscribing": false,
	"requested": false,
	"domain_blocking": false,
	"showing_reblogs": true,
	"endorsed": false
	}
	```

	## `/api/v1/pleroma/accounts/:id/favourites`
	### Returns favorites timeline of any user
	* Method `GET`
	* Authentication: not required
	* Params:
	* `id`: the id of the account for whom to return results
	* `limit`: optional, the number of records to retrieve
	* `since_id`: optional, returns results that are more recent than the specified id
	* `max_id`: optional, returns results that are older than the specified id
	* Response: JSON, returns a list of Mastodon Status entities on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	[
	{
	"account": {
	"id": "9hptFmUF3ztxYh3Svg",
	"url": "https://pleroma.example.org/users/nick2",
	"username": "nick2",
	...
	},
	"application": {"name": "Web", "website": null},
	"bookmarked": false,
	"card": null,
	"content": "This is :moominmamma: note 0",
	"created_at": "2019-04-15T15:42:15.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 1,
	"id": "9hptFmVJ02khbzYJaS",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {"text/plain": "This is :moominmamma: note 0"},
	"conversation_id": 13679,
	"local": true,
	"spoiler_text": {"text/plain": "2hu"}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "2hu",
	"tags": [{"name": "2hu", "url": "/tag/2hu"}],
	"uri": "https://pleroma.example.org/objects/198ed2a1-7912-4482-b559-244a0369e984",
	"url": "https://pleroma.example.org/notice/9hptFmVJ02khbzYJaS",
	"visibility": "public"
	}
	]
	```

	## `/api/v1/pleroma/accounts/update_*`
	### Set and clear account avatar, banner, and background

	- PATCH `/api/v1/pleroma/accounts/update_avatar`: Set/clear user avatar image
	- PATCH `/api/v1/pleroma/accounts/update_banner`: Set/clear user banner image
	- PATCH `/api/v1/pleroma/accounts/update_background`: Set/clear user background image

	## `/api/v1/pleroma/accounts/confirmation_resend`
	### Resend confirmation email
	* Method `POST`
	* Params:
	* `email`: email of that needs to be verified
	* Authentication: not required
	* Response: 204 No Content

	## `/api/v1/pleroma/mascot`
	### Gets user mascot image
	* Method `GET`
	* Authentication: required

	* Response: JSON. Returns a mastodon media attachment entity.
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```

	### Updates user mascot image
	* Method `PUT`
	* Authentication: required
	* Params:
	* `image`: Multipart image
	* Response: JSON. Returns a mastodon media attachment entity
	when successful, otherwise returns HTTP 415 `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```
	* Note: Behaves exactly the same as `POST /api/v1/upload`.
	Can only accept images - any attempt to upload non-image files will be met with `HTTP 415 Unsupported Media Type`.

	## `/api/pleroma/notification_settings`
	### Updates user notification settings
	* Method `PUT`
	* Authentication: required
	* Params:
	* `followers`: BOOLEAN field, receives notifications from followers
	* `follows`: BOOLEAN field, receives notifications from people the user follows
	* `remote`: BOOLEAN field, receives notifications from people on remote instances
	* `local`: BOOLEAN field, receives notifications from people on the local instance
	* `privacy_option`: BOOLEAN field. When set to true, it removes the contents of a message from the push notification.
	* Response: JSON. Returns `{"status": "success"}` if the update was successful, otherwise returns `{"error": "error_msg"}`

	## `/api/pleroma/healthcheck`
	### Healthcheck endpoint with additional system data.
	* Method `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).
	* Example response:
	```json
	{
	"pool_size": 0, # database connection pool
	"active": 0, # active processes
	"idle": 0, # idle processes
	"memory_used": 0.00, # Memory used
	"healthy": true, # Instance state
	"job_queue_stats": {} # Job queue stats
	}
	```

	## `/api/pleroma/change_email`
	### Change account email
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* `email`: new email
	* Response: JSON. Returns `{"status": "success"}` if the change was successful, `{"error": "[error message]"}` otherwise
	* Note: Currently, Mastodon has no API for changing email. If they add it in future it might be incompatible with Pleroma.

	# Pleroma Conversations

	Pleroma Conversations have the same general structure that Mastodon Conversations have. The behavior differs in the following ways when using these endpoints:

	1. Pleroma Conversations never add or remove recipients, unless explicitly changed by the user.
	2. Pleroma Conversations statuses can be requested by Conversation id.
	3. Pleroma Conversations can be replied to.

	Conversations have the additional field `recipients` under the `pleroma` key. This holds a list of all the accounts that will receive a message in this conversation.

	The status posting endpoint takes an additional parameter, `in_reply_to_conversation_id`, which, when set, will set the visiblity to direct and address only the people who are the recipients of that Conversation.

	⚠ Conversation IDs can be found in direct messages with the `pleroma.direct_conversation_id` key, do not confuse it with `pleroma.conversation_id`.

	## `GET /api/v1/pleroma/conversations/:id/statuses`
	### Timeline for a given conversation
	* Method `GET`
	* Authentication: required
	* Params: Like other timelines
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `GET /api/v1/pleroma/conversations/:id`
	### The conversation with the given ID.
	* Method `GET`
	* Authentication: required
	* Params: None
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `PATCH /api/v1/pleroma/conversations/:id`
	### Update a conversation. Used to change the set of recipients.
	* Method `PATCH`
	* Authentication: required
	* Params:
	* `recipients`: A list of ids of users that should receive posts to this conversation. This will replace the current list of recipients, so submit the full list. The owner of owner of the conversation will always be part of the set of recipients, though.
	* Response: JSON, statuses (200 - healthy, 503 unhealthy)

	## `GET /api/v1/pleroma/conversations/read`
	### Marks all user's conversations as read.
	* Method `POST`
	* Authentication: required
	* Params: None
	* Response: JSON, returns a list of Mastodon Conversation entities that were marked as read (200 - healthy, 503 unhealthy).

	## `GET /api/pleroma/emoji/packs`
	### Lists the custom emoji packs on the server
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: JSON, "ok" and 200 status and the JSON hashmap of "pack name" to "pack contents"

	## `PUT /api/pleroma/emoji/packs/:name`
	### Creates an empty custom emoji pack
	* Method `PUT`
	* Authentication: required
	* Params: None
	* Response: JSON, "ok" and 200 status or 409 if the pack with that name already exists

	## `DELETE /api/pleroma/emoji/packs/:name`
	### Delete a custom emoji pack
	* Method `DELETE`
	* Authentication: required
	* Params: None
	* Response: JSON, "ok" and 200 status or 500 if there was an error deleting the pack

	## `POST /api/pleroma/emoji/packs/:name/update_file`
	### Update a file in a custom emoji pack
	* Method `POST`
	* Authentication: required
	* Params:
	* if the `action` is `add`, adds an emoji named `shortcode` to the pack `pack_name`,
	that means that the emoji file needs to be uploaded with the request
	(thus requiring it to be a multipart request) and be named `file`.
	There can also be an optional `filename` that will be the new emoji file name
	(if it's not there, the name will be taken from the uploaded file).
	* if the `action` is `update`, changes emoji shortcode
	(from `shortcode` to `new_shortcode` or moves the file (from the current filename to `new_filename`)
	* if the `action` is `remove`, removes the emoji named `shortcode` and it's associated file
	* Response: JSON, updated "files" section of the pack and 200 status, 409 if the trying to use a shortcode
	that is already taken, 400 if there was an error with the shortcode, filename or file (additional info
	in the "error" part of the response JSON)

	## `POST /api/pleroma/emoji/packs/:name/update_metadata`
	### Updates (replaces) pack metadata
	* Method `POST`
	* Authentication: required
	* Params:
	* `new_data`: new metadata to replace the old one
	* Response: JSON, updated "metadata" section of the pack and 200 status or 400 if there was a
	problem with the new metadata (the error is specified in the "error" part of the response JSON)

	## `POST /api/pleroma/emoji/packs/download_from`
	### Requests the instance to download the pack from another instance
	* Method `POST`
	* Authentication: required
	* Params:
	* `instance_address`: the address of the instance to download from
	* `pack_name`: the pack to download from that instance
	* Response: JSON, "ok" and 200 status if the pack was downloaded, or 500 if there were
	errors downloading the pack

	## `POST /api/pleroma/emoji/packs/list_from`
	### Requests the instance to list the packs from another instance
	* Method `POST`
	* Authentication: required
	* Params:
	* `instance_address`: the address of the instance to download from
	* Response: JSON with the pack list, same as if the request was made to that instance's
	list endpoint directly + 200 status

	## `GET /api/pleroma/emoji/packs/:name/download_shared`
	### Requests a local pack from the instance
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: the archive of the pack with a 200 status code, 403 if the pack is not set as shared,
	404 if the pack does not exist

	## `GET /api/v1/pleroma/accounts/:id/scrobbles`
	### Requests a list of current and recent Listen activities for an account
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: An array of media metadata entities.
	* Example response:
	```json
	[
	{
	"account": {...},
	"id": "1234",
	"title": "Some Title",
	"artist": "Some Artist",
	"album": "Some Album",
	"length": 180000,
	"created_at": "2019-09-28T12:40:45.000Z"
	}
	]
	```

	## `POST /api/v1/pleroma/scrobble`
	### Creates a new Listen activity for an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `title`: the title of the media playing
	* `album`: the album of the media playing [optional]
	* `artist`: the artist of the media playing [optional]
	* `length`: the length of the media playing [optional]
	* Response: the newly created media metadata entity representing the Listen activity

	# Emoji Reactions

	-Emoji reactions work a lot like favourites do. They make it possible to react to a post with a single emoji character.
	+Emoji reactions work a lot like favourites do. They make it possible to react to a post with a single emoji character. To detect the presence of this feature, you can check `pleroma_emoji_reactions` entry in the features list of nodeinfo.

	## `PUT /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### React to a post with a unicode emoji
	* Method: `PUT`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### Remove a reaction to a post with a unicode emoji
	* Method: `DELETE`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `GET /api/v1/pleroma/statuses/:id/reactions`
	### Get an object of emoji to account mappings with accounts that reacted to the post
	* Method: `GET`
	* Authentication: optional
	* Params: None
	* Response: JSON, a list of emoji/account list tuples, sorted by emoji insertion date, in ascending order, e.g, the first emoji in the list is the oldest.
	* Example Response:
	```json
	[
	{"name": "😀", "count": 2, "me": true, "accounts": [{"id" => "xyz.."...}, {"id" => "zyx..."}]},
	{"name": "☕", "count": 1, "me": false, "accounts": [{"id" => "abc..."}]}
	]
	```

	## `GET /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### Get an object of emoji to account mappings with accounts that reacted to the post for a specific emoji`
	* Method: `GET`
	* Authentication: optional
	* Params: None
	* Response: JSON, a list of emoji/account list tuples
	* Example Response:
	```json
	[
	{"name": "😀", "count": 2, "me": true, "accounts": [{"id" => "xyz.."...}, {"id" => "zyx..."}]}
	]
	```
	diff --git a/docs/administration/CLI_tasks/emoji.md b/docs/administration/CLI_tasks/emoji.md
	index efec8222c..3d524a52b 100644
	--- a/docs/administration/CLI_tasks/emoji.md
	+++ b/docs/administration/CLI_tasks/emoji.md
	@@ -1,46 +1,46 @@
	# Managing emoji packs

	{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Lists emoji packs and metadata specified in the manifest

	```sh tab="OTP"
	./bin/pleroma_ctl emoji ls-packs [option ...]
	```

	```sh tab="From Source"
	mix pleroma.emoji ls-packs [option ...]
	```


	### Options
	- `-m, --manifest PATH/URL` - path to a custom manifest, it can either be an URL starting with `http`, in that case the manifest will be fetched from that address, or a local path

	## Fetch, verify and install the specified packs from the manifest into `STATIC-DIR/emoji/PACK-NAME`

	```sh tab="OTP"
	./bin/pleroma_ctl emoji get-packs [option ...] <pack ...>
	```

	```sh tab="From Source"
	mix pleroma.emoji get-packs [option ...] <pack ...>
	```

	### Options
	- `-m, --manifest PATH/URL` - same as [`ls-packs`](#ls-packs)

	## Create a new manifest entry and a file list from the specified remote pack file

	```sh tab="OTP"
	./bin/pleroma_ctl emoji gen-pack PACK-URL
	```

	```sh tab="From Source"
	mix pleroma.emoji gen-pack PACK-URL
	```

	-Currently, only .zip archives are recognized as remote pack files and packs are therefore assumed to be zip archives. This command is intended to run interactively and will first ask you some basic questions about the pack, then download the remote file and generate an SHA256 checksum for it, then generate an emoji file list for you.
	+Currently, only .zip archives are recognized as remote pack files and packs are therefore assumed to be zip archives. This command is intended to run interactively and will first ask you some basic questions about the pack, then download the remote file and generate an SHA256 checksum for it, then generate an emoji file list for you.

	- The manifest entry will either be written to a newly created `index.json` file or appended to the existing one, replacing the old pack with the same name if it was in the file previously.
	+ The manifest entry will either be written to a newly created `pack_name.json` file (pack name is asked in questions) or appended to the existing one, replacing the old pack with the same name if it was in the file previously.

	The file list will be written to the file specified previously, replacing that file. You _should_ check that the file list doesn't contain anything you don't need in the pack, that is, anything that is not an emoji (the whole pack is downloaded, but only emoji files are extracted).
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	index 429d763c7..cdffa88b2 100644
	--- a/lib/mix/tasks/pleroma/emoji.ex
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -1,253 +1,271 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Emoji do
	use Mix.Task
	import Mix.Pleroma

	@shortdoc "Manages emoji packs"
	@moduledoc File.read!("docs/administration/CLI_tasks/emoji.md")

	def run(["ls-packs" \| args]) do
	start_pleroma()

	{options, [], []} = parse_global_opts(args)

	- manifest =
	- fetch_manifest(if options[:manifest], do: options[:manifest], else: default_manifest())
	+ url_or_path = options[:manifest] \|\| default_manifest()
	+ manifest = fetch_manifest(url_or_path)

	Enum.each(manifest, fn {name, info} ->
	to_print = [
	{"Name", name},
	{"Homepage", info["homepage"]},
	{"Description", info["description"]},
	{"License", info["license"]},
	{"Source", info["src"]}
	]

	for {param, value} <- to_print do
	IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
	end

	# A newline
	IO.puts("")
	end)
	end

	def run(["get-packs" \| args]) do
	start_pleroma()

	{options, pack_names, []} = parse_global_opts(args)

	- manifest_url = if options[:manifest], do: options[:manifest], else: default_manifest()
	+ url_or_path = options[:manifest] \|\| default_manifest()

	- manifest = fetch_manifest(manifest_url)
	+ manifest = fetch_manifest(url_or_path)

	for pack_name <- pack_names do
	if Map.has_key?(manifest, pack_name) do
	pack = manifest[pack_name]
	src_url = pack["src"]

	IO.puts(
	IO.ANSI.format([
	"Downloading ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	src_url
	])
	)

	binary_archive = Tesla.get!(client(), src_url).body
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]

	if archive_sha == String.upcase(pack["src_sha256"]) do
	IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
	else
	IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))

	raise "Bad SHA256 for #{pack_name}"
	end

	# The url specified in files should be in the same directory
	- files_url = Path.join(Path.dirname(manifest_url), pack["files"])
	+ files_url =
	+ url_or_path
	+ \|> Path.dirname()
	+ \|> Path.join(pack["files"])

	IO.puts(
	IO.ANSI.format([
	"Fetching the file list for ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	files_url
	])
	)

	files = Tesla.get!(client(), files_url).body \|> Jason.decode!()

	IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))

	pack_path =
	Path.join([
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji",
	pack_name
	])

	files_to_unzip =
	Enum.map(
	files,
	fn {_, f} -> to_charlist(f) end
	)

	{:ok, _} =
	:zip.unzip(binary_archive,
	cwd: pack_path,
	file_list: files_to_unzip
	)

	IO.puts(IO.ANSI.format(["Writing pack.json for ", :bright, pack_name]))

	pack_json = %{
	pack: %{
	"license" => pack["license"],
	"homepage" => pack["homepage"],
	"description" => pack["description"],
	"fallback-src" => pack["src"],
	"fallback-src-sha256" => pack["src_sha256"],
	"share-files" => true
	},
	files: files
	}

	File.write!(Path.join(pack_path, "pack.json"), Jason.encode!(pack_json, pretty: true))
	else
	IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	end
	end
	end

	- def run(["gen-pack", src]) do
	+ def run(["gen-pack" \| args]) do
	start_pleroma()

	- proposed_name = Path.basename(src) \|> Path.rootname()
	- name = String.trim(IO.gets("Pack name [#{proposed_name}]: "))
	- # If there's no name, use the default one
	- name = if String.length(name) > 0, do: name, else: proposed_name
	+ {opts, [src], []} =
	+ OptionParser.parse(
	+ args,
	+ strict: [
	+ name: :string,
	+ license: :string,
	+ homepage: :string,
	+ description: :string,
	+ files: :string,
	+ extensions: :string
	+ ]
	+ )

	- license = String.trim(IO.gets("License: "))
	- homepage = String.trim(IO.gets("Homepage: "))
	- description = String.trim(IO.gets("Description: "))
	+ proposed_name = Path.basename(src) \|> Path.rootname()
	+ name = get_option(opts, :name, "Pack name:", proposed_name)
	+ license = get_option(opts, :license, "License:")
	+ homepage = get_option(opts, :homepage, "Homepage:")
	+ description = get_option(opts, :description, "Description:")

	- proposed_files_name = "#{name}.json"
	- files_name = String.trim(IO.gets("Save file list to [#{proposed_files_name}]: "))
	- files_name = if String.length(files_name) > 0, do: files_name, else: proposed_files_name
	+ proposed_files_name = "#{name}_files.json"
	+ files_name = get_option(opts, :files, "Save file list to:", proposed_files_name)

	default_exts = [".png", ".gif"]
	- default_exts_str = Enum.join(default_exts, " ")

	- exts =
	- String.trim(
	- IO.gets("Emoji file extensions (separated with spaces) [#{default_exts_str}]: ")
	+ custom_exts =
	+ get_option(
	+ opts,
	+ :extensions,
	+ "Emoji file extensions (separated with spaces):",
	+ Enum.join(default_exts, " ")
	)
	+ \|> String.split(" ", trim: true)

	exts =
	- if String.length(exts) > 0 do
	- String.split(exts, " ")
	- \|> Enum.filter(fn e -> e \|> String.trim() \|> String.length() > 0 end)
	- else
	+ if MapSet.equal?(MapSet.new(default_exts), MapSet.new(custom_exts)) do
	default_exts
	+ else
	+ custom_exts
	end

	+ IO.puts("Using #{Enum.join(exts, " ")} extensions")
	+
	IO.puts("Downloading the pack and generating SHA256")

	binary_archive = Tesla.get!(client(), src).body
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	IO.puts("SHA256 is #{archive_sha}")

	pack_json = %{
	name => %{
	license: license,
	homepage: homepage,
	description: description,
	src: src,
	src_sha256: archive_sha,
	files: files_name
	}
	}

	tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")

	{:ok, _} = :zip.unzip(binary_archive, cwd: String.to_charlist(tmp_pack_dir))

	emoji_map = Pleroma.Emoji.Loader.make_shortcode_to_file_map(tmp_pack_dir, exts)

	File.write!(files_name, Jason.encode!(emoji_map, pretty: true))

	IO.puts("""

	#{files_name} has been created and contains the list of all found emojis in the pack.
	- Please review the files in the remove those not needed.
	+ Please review the files in the pack and remove those not needed.
	""")

	- if File.exists?("index.json") do
	- existing_data = File.read!("index.json") \|> Jason.decode!()
	+ pack_file = "#{name}.json"
	+
	+ if File.exists?(pack_file) do
	+ existing_data = File.read!(pack_file) \|> Jason.decode!()

	File.write!(
	- "index.json",
	+ pack_file,
	Jason.encode!(
	Map.merge(
	existing_data,
	pack_json
	),
	pretty: true
	)
	)

	- IO.puts("index.json file has been update with the #{name} pack")
	+ IO.puts("#{pack_file} has been updated with the #{name} pack")
	else
	- File.write!("index.json", Jason.encode!(pack_json, pretty: true))
	+ File.write!(pack_file, Jason.encode!(pack_json, pretty: true))

	- IO.puts("index.json has been created with the #{name} pack")
	+ IO.puts("#{pack_file} has been created with the #{name} pack")
	end
	end

	defp fetch_manifest(from) do
	Jason.decode!(
	if String.starts_with?(from, "http") do
	Tesla.get!(client(), from).body
	else
	File.read!(from)
	end
	)
	end

	defp parse_global_opts(args) do
	OptionParser.parse(
	args,
	strict: [
	manifest: :string
	],
	aliases: [
	m: :manifest
	]
	)
	end

	defp client do
	middleware = [
	{Tesla.Middleware.FollowRedirects, [max_redirects: 3]}
	]

	Tesla.client(middleware)
	end

	defp default_manifest, do: Pleroma.Config.get!([:emoji, :default_manifest])
	end
	diff --git a/lib/pleroma/object/containment.ex b/lib/pleroma/object/containment.ex
	index 9ae6a5600..99608b8a5 100644
	--- a/lib/pleroma/object/containment.ex
	+++ b/lib/pleroma/object/containment.ex
	@@ -1,75 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Containment do
	@moduledoc """
	This module contains some useful functions for containing objects to specific
	origins and determining those origins. They previously lived in the
	ActivityPub `Transmogrifier` module.

	Object containment is an important step in validating remote objects to prevent
	spoofing, therefore removal of object containment functions is NOT recommended.
	"""
	def get_actor(%{"actor" => actor}) when is_binary(actor) do
	actor
	end

	def get_actor(%{"actor" => actor}) when is_list(actor) do
	if is_binary(Enum.at(actor, 0)) do
	Enum.at(actor, 0)
	else
	Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	\|> Map.get("id")
	end
	end

	def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	id
	end

	def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	get_actor(%{"actor" => actor})
	end

	+ def get_object(%{"object" => id}) when is_binary(id) do
	+ id
	+ end
	+
	+ def get_object(%{"object" => %{"id" => id}}) when is_binary(id) do
	+ id
	+ end
	+
	+ def get_object(_) do
	+ nil
	+ end
	+
	# TODO: We explicitly allow 'tag' URIs through, due to references to legacy OStatus
	# objects being present in the test suite environment. Once these objects are
	# removed, please also remove this.
	if Mix.env() == :test do
	defp compare_uris(_, %URI{scheme: "tag"}), do: :ok
	end

	defp compare_uris(%URI{host: host} = _id_uri, %URI{host: host} = _other_uri), do: :ok
	defp compare_uris(_id_uri, _other_uri), do: :error

	@doc """
	Checks that an imported AP object's actor matches the domain it came from.
	"""
	def contain_origin(_id, %{"actor" => nil}), do: :error

	def contain_origin(id, %{"actor" => _actor} = params) do
	id_uri = URI.parse(id)
	actor_uri = URI.parse(get_actor(params))

	compare_uris(actor_uri, id_uri)
	end

	def contain_origin(id, %{"attributedTo" => actor} = params),
	do: contain_origin(id, Map.put(params, "actor", actor))

	def contain_origin(_id, _data), do: :error

	def contain_origin_from_id(id, %{"id" => other_id} = _params) when is_binary(other_id) do
	id_uri = URI.parse(id)
	other_uri = URI.parse(other_id)

	compare_uris(id_uri, other_uri)
	end

	def contain_origin_from_id(_id, _data), do: :error

	def contain_child(%{"object" => %{"id" => id, "attributedTo" => _} = object}),
	do: contain_origin(id, object)

	def contain_child(_), do: :ok
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 53b6ad654..19286fd01 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1574 +1,1589 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	require Logger
	require Pleroma.Constants

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients =
	Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil -> true
	user -> User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

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

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

	defp check_actor_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.deactivated do
	true
	else
	_e -> false
	end
	else
	true
	end
	end

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

	defp check_remote_limit(_), do: true

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

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

	def increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	def increase_replies_count_if_reply(_create_data), do: :noop

	def decrease_replies_count_if_reply(%Object{
	data: %{"inReplyTo" => reply_ap_id} = object
	}) do
	if is_public?(object) do
	Object.decrease_replies_count(reply_ap_id)
	end
	end

	def decrease_replies_count_if_reply(_object), do: :noop

	def increase_poll_votes_if_vote(%{
	"object" => %{"inReplyTo" => reply_ap_id, "name" => name},
	"type" => "Create"
	}) do
	Object.increase_vote_count(reply_ap_id, name)
	end

	def increase_poll_votes_if_vote(_create_data), do: :noop

	+ @spec persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	+ def persist(object, meta) do
	+ with local <- Keyword.fetch!(meta, :local),
	+ {recipients, _, _} <- get_recipients(object),
	+ {:ok, activity} <-
	+ Repo.insert(%Activity{
	+ data: object,
	+ local: local,
	+ recipients: recipients,
	+ actor: object["actor"]
	+ }) do
	+ {:ok, activity, meta}
	+ end
	+ end
	+
	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	true <- bypass_actor_check \|\| check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map) do
	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	# Splice in the child object if we have one.
	activity =
	if not is_nil(object) do
	Map.put(activity, :object, object)
	else
	activity
	end

	BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})

	Notification.create_notifications(activity)

	conversation = create_or_bump_conversation(activity, map["actor"])
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

	error ->
	{:error, error}
	end
	end

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor),
	Participation.mark_as_read(user, conversation) do
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
	conversation = Repo.preload(conversation, :participations),
	last_activity_id =
	fetch_latest_activity_id_for_context(conversation.ap_id, %{
	"user" => user,
	"blocking_user" => user
	}) do
	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	def stream_out_participations(_, _), do: :noop

	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	def stream_out(_activity) do
	:noop
	end

	@spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def create(params, fake \\ false) do
	with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	result
	end
	end

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_poll_votes_if_vote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	with listen_data <-
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(listen_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec accept(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept(params) do
	accept_or_reject("Accept", params)
	end

	@spec reject(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def reject(params) do
	accept_or_reject("Reject", params)
	end

	@spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
	local = Map.get(params, :local, true)
	activity_id = Map.get(params, :activity_id, nil)

	with data <-
	%{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
	\|> Utils.maybe_put("id", activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec update(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	local = !(params[:local] == false)
	activity_id = params[:activity_id]

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	data <- Utils.maybe_put(data, "id", activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec react_with_emoji(User.t(), Object.t(), String.t(), keyword()) ::
	{:ok, Activity.t(), Object.t()} \| {:error, any()}
	def react_with_emoji(user, object, emoji, options \\ []) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_react_with_emoji(user, object, emoji, options) end) do
	result
	end
	end

	defp do_react_with_emoji(user, object, emoji, options) do
	with local <- Keyword.get(options, :local, true),
	activity_id <- Keyword.get(options, :activity_id, nil),
	true <- Pleroma.Emoji.is_unicode_emoji?(emoji),
	reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
	{:ok, activity} <- insert(reaction_data, local),
	{:ok, object} <- add_emoji_reaction_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	false -> {:error, false}
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec unreact_with_emoji(User.t(), String.t(), keyword()) ::
	{:ok, Activity.t(), Object.t()} \| {:error, any()}
	def unreact_with_emoji(user, reaction_id, options \\ []) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unreact_with_emoji(user, reaction_id, options) end) do
	result
	end
	end

	defp do_unreact_with_emoji(user, reaction_id, options) do
	with local <- Keyword.get(options, :local, true),
	activity_id <- Keyword.get(options, :activity_id, nil),
	user_ap_id <- user.ap_id,
	%Activity{actor: ^user_ap_id} = reaction_activity <- Activity.get_by_ap_id(reaction_id),
	object <- Object.normalize(reaction_activity),
	unreact_data <- make_undo_data(user, reaction_activity, activity_id),
	{:ok, activity} <- insert(unreact_data, local),
	{:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	@spec like(User.t(), Object.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t(), Object.t()} \| {:error, any()}
	def like(user, object, activity_id \\ nil, local \\ true) do
	with {:ok, result} <- Repo.transaction(fn -> do_like(user, object, activity_id, local) end) do
	result
	end
	end

	defp do_like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id,
	local
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity ->
	{:ok, activity, object}

	{:error, error} ->
	Repo.rollback(error)
	end
	end

	@spec unlike(User.t(), Object.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t(), Activity.t(), Object.t()} \| {:ok, Object.t()} \| {:error, any()}
	def unlike(%User{} = actor, %Object{} = object, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unlike(actor, object, activity_id, local) end) do
	result
	end
	end

	defp do_unlike(actor, object, activity_id, local) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	nil -> {:ok, object}
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec announce(User.t(), Object.t(), String.t() \| nil, boolean(), boolean()) ::
	{:ok, Activity.t(), Object.t()} \| {:error, any()}
	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_announce(user, object, activity_id, local, public) end) do
	result
	end
	end

	defp do_announce(user, object, activity_id, local, public) do
	with true <- is_announceable?(object, user, public),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	false -> {:error, false}
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec unannounce(User.t(), Object.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t(), Object.t()} \| {:ok, Object.t()} \| {:error, any()}
	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unannounce(actor, object, activity_id, local) end) do
	result
	end
	end

	defp do_unannounce(actor, object, activity_id, local) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	nil -> {:ok, object}
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec follow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| {:error, any()}
	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_follow(follower, followed, activity_id, local) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec delete(User.t() \| Object.t(), keyword()) :: {:ok, User.t() \| Object.t()} \| {:error, any()}
	def delete(entity, options \\ []) do
	with {:ok, result} <- Repo.transaction(fn -> do_delete(entity, options) end) do
	result
	end
	end

	defp do_delete(%User{ap_id: ap_id, follower_address: follower_address} = user, _) do
	with data <- %{
	"to" => [follower_address],
	"type" => "Delete",
	"actor" => ap_id,
	"object" => %{"type" => "Person", "id" => ap_id}
	},
	{:ok, activity} <- insert(data, true, true, true),
	:ok <- maybe_federate(activity) do
	{:ok, user}
	end
	end

	defp do_delete(%Object{data: %{"id" => id, "actor" => actor}} = object, options) do
	local = Keyword.get(options, :local, true)
	activity_id = Keyword.get(options, :activity_id, nil)
	actor = Keyword.get(options, :actor, actor)

	user = User.get_cached_by_ap_id(actor)
	to = (object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	with create_activity <- Activity.get_create_by_object_ap_id(id),
	data <-
	%{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => to,
	"deleted_activity_id" => create_activity && create_activity.id
	}
	\|> maybe_put("id", activity_id),
	{:ok, activity} <- insert(data, local, false),
	{:ok, object, _create_activity} <- Object.delete(object),
	stream_out_participations(object, user),
	_ <- decrease_replies_count_if_reply(object),
	{:ok, _actor} <- decrease_note_count_if_public(user, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} ->
	Repo.rollback(error)
	end
	end

	defp do_delete(%Object{data: %{"type" => "Tombstone", "id" => ap_id}}, _) do
	activity =
	ap_id
	\|> Activity.Queries.by_object_id()
	\|> Activity.Queries.by_type("Delete")
	\|> Repo.one()

	{:ok, activity}
	end

	@spec block(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| {:error, any()}
	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
	result
	end
	end

	defp do_block(blocker, blocked, activity_id, local) do
	outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
	unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])

	if unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)
	if follow_activity, do: unfollow(blocker, blocked, nil, local)
	end

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec unblock(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| {:error, any()} \| nil
	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unblock(blocker, blocked, activity_id, local) end) do
	result
	end
	end

	defp do_unblock(blocker, blocked, activity_id, local) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	{:ok, stripped_activity} <- strip_report_status_data(activity),
	:ok <- maybe_federate(stripped_activity) do
	User.all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local) do
	maybe_federate(activity)

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	defp fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts["user"],
	do: [opts["user"].ap_id \| User.following(opts["user"])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	@spec fetch_latest_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts = Map.drop(opts, ["user"])

	[Constants.as_public()]
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted()
	\|> Pagination.fetch_paginated(opts, pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query =
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)

	query
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(
	query,
	%{"user" => %User{skip_thread_containment: true}},
	_
	),
	do: query

	defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("user", reading_user)
	\|> Map.put("actor_id", user.ap_id)

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("user", reading_user)
	\|> Map.put("actor_id", user.ap_id)
	\|> Map.put("pinned_activity_ids", user.pinned_activities)

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put("blocking_user", reading_user)
	\|> Map.put("muting_user", reading_user)
	end

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_statuses(reading_user, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{"godmode" => true}) do
	[]
	end

	defp user_activities_recipients(%{"reading_user" => reading_user}) do
	if reading_user do
	[Constants.as_public()] ++ [reading_user.ap_id \| User.following(reading_user)]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_since(query, %{"since_id" => ""}), do: query

	defp restrict_since(query, %{"since_id" => since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
	when is_list(tag_reject) and tag_reject != [] do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_all(query, %{"tag_all" => tag_all})
	when is_list(tag_all) and tag_all != [] do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{"local_only" => true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_actor(query, %{"actor_id" => actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{"type" => type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{"type" => type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{"state" => state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
	from(
	[_activity, object] in query,
	where: fragment("?->>'inReplyTo' is null", object.data)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query

	defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
	mutes = opts["muted_users_ap_ids"] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^mutes)
	)

	unless opts["skip_preload"] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
	blocked_ap_ids = opts["blocked_users_ap_ids"] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
	where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
	muted_reblogs = opts["reblog_muted_users_ap_ids"] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{"instance" => instance}) do
	users =
	from(
	u in User,
	select: u.ap_id,
	where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
	)
	\|> Repo.all()

	from(activity in query, where: activity.actor in ^users)
	end

	defp restrict_instance(query, _), do: query

	defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts["user"])
	end

	defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts["muting_user"] \|\| opts["user"])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts["muting_user"]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	ap_id_relationships ++
	if opts["blocking_user"] && opts["blocking_user"] == source_user do
	[:block]
	else
	[]
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_visibility(opts)
	end

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts["user"])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts["user"])
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([_like, object, activity], %{activity \| object: object})
	\|> order_by([like, _, _], desc: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{"skip_order" => true}),
	pagination,
	:object_activity
	)
	end

	defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
	when is_list(list_memberships) and length(list_memberships) > 0 do
	Enum.map(activities, fn
	%{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

	Repo.insert(%Object{data: obj_data})
	end
	end

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp object_to_user_data(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)
	discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	user_data = %{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	ap_enabled: true,
	source_data: data,
	banner: banner,
	fields: fields,
	locked: locked,
	discoverable: discoverable,
	invisible: invisible,
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"],
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", [])
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	defp maybe_update_follow_information(data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{:ok, info} <- fetch_follow_information_for_user(data) do
	info = Map.merge(data[:info] \|\| %{}, info)
	Map.put(data, :info, info)
	else
	{:enabled, false} ->
	data

	e ->
	Logger.error(
	"Follower/Following counter update for #{data.ap_id} failed.\n" <> inspect(e)
	)

	data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data) do
	with {:ok, data} <- MRF.filter(data),
	{:ok, data} <- object_to_user_data(data) do
	{:ok, data}
	else
	e -> {:error, e}
	end
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data),
	data <- maybe_update_follow_information(data) do
	{:ok, data}
	else
	{:error, "Object has been deleted"} = e ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	e ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_cached_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	def contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{"type" => "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	new file mode 100644
	index 000000000..429a510b8
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -0,0 +1,43 @@
	+defmodule Pleroma.Web.ActivityPub.Builder do
	+ @moduledoc """
	+ This module builds the objects. Meant to be used for creating local objects.
	+
	+ This module encodes our addressing policies and general shape of our objects.
	+ """
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.ActivityPub.Visibility
	+
	+ @spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	+ def like(actor, object) do
	+ object_actor = User.get_cached_by_ap_id(object.data["actor"])
	+
	+ # Address the actor of the object, and our actor's follower collection if the post is public.
	+ to =
	+ if Visibility.is_public?(object) do
	+ [actor.follower_address, object.data["actor"]]
	+ else
	+ [object.data["actor"]]
	+ end
	+
	+ # CC everyone who's been addressed in the object, except ourself and the object actor's
	+ # follower collection
	+ cc =
	+ (object.data["to"] ++ (object.data["cc"] \|\| []))
	+ \|> List.delete(actor.ap_id)
	+ \|> List.delete(object_actor.follower_address)
	+
	+ {:ok,
	+ %{
	+ "id" => Utils.generate_activity_id(),
	+ "actor" => actor.ap_id,
	+ "type" => "Like",
	+ "object" => object.data["id"],
	+ "to" => to,
	+ "cc" => cc,
	+ "context" => object.data["context"]
	+ }, []}
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	new file mode 100644
	index 000000000..dc4bce059
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -0,0 +1,37 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidator do
	+ @moduledoc """
	+ This module is responsible for validating an object (which can be an activity)
	+ and checking if it is both well formed and also compatible with our view of
	+ the system.
	+ """
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	+
	+ @spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	+ def validate(object, meta)
	+
	+ def validate(%{"type" => "Like"} = object, meta) do
	+ with {:ok, object} <-
	+ object \|> LikeValidator.cast_and_validate() \|> Ecto.Changeset.apply_action(:insert) do
	+ object = stringify_keys(object \|> Map.from_struct())
	+ {:ok, object, meta}
	+ end
	+ end
	+
	+ def stringify_keys(object) do
	+ object
	+ \|> Map.new(fn {key, val} -> {to_string(key), val} end)
	+ end
	+
	+ def fetch_actor_and_object(object) do
	+ User.get_or_fetch_by_ap_id(object["actor"])
	+ Object.normalize(object["object"])
	+ :ok
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_validations.ex b/lib/pleroma/web/activity_pub/object_validators/common_validations.ex
	new file mode 100644
	index 000000000..b479c3918
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_validations.ex
	@@ -0,0 +1,32 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations do
	+ import Ecto.Changeset
	+
	+ alias Pleroma.Object
	+ alias Pleroma.User
	+
	+ def validate_actor_presence(cng, field_name \\ :actor) do
	+ cng
	+ \|> validate_change(field_name, fn field_name, actor ->
	+ if User.get_cached_by_ap_id(actor) do
	+ []
	+ else
	+ [{field_name, "can't find user"}]
	+ end
	+ end)
	+ end
	+
	+ def validate_object_presence(cng, field_name \\ :object) do
	+ cng
	+ \|> validate_change(field_name, fn field_name, object ->
	+ if Object.get_cached_by_ap_id(object) do
	+ []
	+ else
	+ [{field_name, "can't find object"}]
	+ end
	+ end)
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_validator.ex
	new file mode 100644
	index 000000000..926804ce7
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_validator.ex
	@@ -0,0 +1,30 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.CreateNoteValidator do
	+ use Ecto.Schema
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.NoteValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+
	+ import Ecto.Changeset
	+
	+ @primary_key false
	+
	+ embedded_schema do
	+ field(:id, Types.ObjectID, primary_key: true)
	+ field(:actor, Types.ObjectID)
	+ field(:type, :string)
	+ field(:to, {:array, :string})
	+ field(:cc, {:array, :string})
	+ field(:bto, {:array, :string}, default: [])
	+ field(:bcc, {:array, :string}, default: [])
	+
	+ embeds_one(:object, NoteValidator)
	+ end
	+
	+ def cast_data(data) do
	+ cast(%__MODULE__{}, data, __schema__(:fields))
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/like_validator.ex b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	new file mode 100644
	index 000000000..49546ceaa
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	@@ -0,0 +1,57 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator do
	+ use Ecto.Schema
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+ alias Pleroma.Web.ActivityPub.Utils
	+
	+ import Ecto.Changeset
	+ import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+
	+ @primary_key false
	+
	+ embedded_schema do
	+ field(:id, Types.ObjectID, primary_key: true)
	+ field(:type, :string)
	+ field(:object, Types.ObjectID)
	+ field(:actor, Types.ObjectID)
	+ field(:context, :string)
	+ field(:to, {:array, :string})
	+ field(:cc, {:array, :string})
	+ end
	+
	+ def cast_and_validate(data) do
	+ data
	+ \|> cast_data()
	+ \|> validate_data()
	+ end
	+
	+ def cast_data(data) do
	+ %__MODULE__{}
	+ \|> cast(data, [:id, :type, :object, :actor, :context, :to, :cc])
	+ end
	+
	+ def validate_data(data_cng) do
	+ data_cng
	+ \|> validate_inclusion(:type, ["Like"])
	+ \|> validate_required([:id, :type, :object, :actor, :context, :to, :cc])
	+ \|> validate_actor_presence()
	+ \|> validate_object_presence()
	+ \|> validate_existing_like()
	+ end
	+
	+ def validate_existing_like(%{changes: %{actor: actor, object: object}} = cng) do
	+ if Utils.get_existing_like(actor, %{data: %{"id" => object}}) do
	+ cng
	+ \|> add_error(:actor, "already liked this object")
	+ \|> add_error(:object, "already liked by this actor")
	+ else
	+ cng
	+ end
	+ end
	+
	+ def validate_existing_like(cng), do: cng
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	new file mode 100644
	index 000000000..c95b622e4
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	@@ -0,0 +1,63 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.NoteValidator do
	+ use Ecto.Schema
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+
	+ import Ecto.Changeset
	+
	+ @primary_key false
	+
	+ embedded_schema do
	+ field(:id, Types.ObjectID, primary_key: true)
	+ field(:to, {:array, :string}, default: [])
	+ field(:cc, {:array, :string}, default: [])
	+ field(:bto, {:array, :string}, default: [])
	+ field(:bcc, {:array, :string}, default: [])
	+ # TODO: Write type
	+ field(:tag, {:array, :map}, default: [])
	+ field(:type, :string)
	+ field(:content, :string)
	+ field(:context, :string)
	+ field(:actor, Types.ObjectID)
	+ field(:attributedTo, Types.ObjectID)
	+ field(:summary, :string)
	+ field(:published, Types.DateTime)
	+ # TODO: Write type
	+ field(:emoji, :map, default: %{})
	+ field(:sensitive, :boolean, default: false)
	+ # TODO: Write type
	+ field(:attachment, {:array, :map}, default: [])
	+ field(:replies_count, :integer, default: 0)
	+ field(:like_count, :integer, default: 0)
	+ field(:announcement_count, :integer, default: 0)
	+ field(:inRepyTo, :string)
	+
	+ field(:likes, {:array, :string}, default: [])
	+ field(:announcements, {:array, :string}, default: [])
	+
	+ # see if needed
	+ field(:conversation, :string)
	+ field(:context_id, :string)
	+ end
	+
	+ def cast_and_validate(data) do
	+ data
	+ \|> cast_data()
	+ \|> validate_data()
	+ end
	+
	+ def cast_data(data) do
	+ %__MODULE__{}
	+ \|> cast(data, __schema__(:fields))
	+ end
	+
	+ def validate_data(data_cng) do
	+ data_cng
	+ \|> validate_inclusion(:type, ["Note"])
	+ \|> validate_required([:id, :actor, :to, :cc, :type, :content, :context])
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/date_time.ex b/lib/pleroma/web/activity_pub/object_validators/types/date_time.ex
	new file mode 100644
	index 000000000..4f412fcde
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/types/date_time.ex
	@@ -0,0 +1,34 @@
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTime do
	+ @moduledoc """
	+ The AP standard defines the date fields in AP as xsd:DateTime. Elixir's
	+ DateTime can't parse this, but it can parse the related iso8601. This
	+ module punches the date until it looks like iso8601 and normalizes to
	+ it.
	+
	+ DateTimes without a timezone offset are treated as UTC.
	+
	+ Reference: https://www.w3.org/TR/activitystreams-vocabulary/#dfn-published
	+ """
	+ use Ecto.Type
	+
	+ def type, do: :string
	+
	+ def cast(datetime) when is_binary(datetime) do
	+ with {:ok, datetime, _} <- DateTime.from_iso8601(datetime) do
	+ {:ok, DateTime.to_iso8601(datetime)}
	+ else
	+ {:error, :missing_offset} -> cast("#{datetime}Z")
	+ _e -> :error
	+ end
	+ end
	+
	+ def cast(_), do: :error
	+
	+ def dump(data) do
	+ {:ok, data}
	+ end
	+
	+ def load(data) do
	+ {:ok, data}
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/object_id.ex b/lib/pleroma/web/activity_pub/object_validators/types/object_id.ex
	new file mode 100644
	index 000000000..ee10be0b0
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/types/object_id.ex
	@@ -0,0 +1,33 @@
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.ObjectID do
	+ use Ecto.Type
	+
	+ def type, do: :string
	+
	+ def cast(object) when is_binary(object) do
	+ # Host has to be present and scheme has to be an http scheme (for now)
	+ case URI.parse(object) do
	+ %URI{host: nil} ->
	+ :error
	+
	+ %URI{scheme: scheme} when scheme in ["https", "http"] ->
	+ {:ok, object}
	+
	+ _ ->
	+ :error
	+ end
	+ end
	+
	+ def cast(%{"id" => object}), do: cast(object)
	+
	+ def cast(_) do
	+ :error
	+ end
	+
	+ def dump(data) do
	+ {:ok, data}
	+ end
	+
	+ def load(data) do
	+ {:ok, data}
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/pipeline.ex b/lib/pleroma/web/activity_pub/pipeline.ex
	new file mode 100644
	index 000000000..7ccee54c9
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/pipeline.ex
	@@ -0,0 +1,42 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.Pipeline do
	+ alias Pleroma.Activity
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.MRF
	+ alias Pleroma.Web.ActivityPub.ObjectValidator
	+ alias Pleroma.Web.ActivityPub.SideEffects
	+ alias Pleroma.Web.Federator
	+
	+ @spec common_pipeline(map(), keyword()) :: {:ok, Activity.t(), keyword()} \| {:error, any()}
	+ def common_pipeline(object, meta) do
	+ with {_, {:ok, validated_object, meta}} <-
	+ {:validate_object, ObjectValidator.validate(object, meta)},
	+ {_, {:ok, mrfd_object}} <- {:mrf_object, MRF.filter(validated_object)},
	+ {_, {:ok, %Activity{} = activity, meta}} <-
	+ {:persist_object, ActivityPub.persist(mrfd_object, meta)},
	+ {_, {:ok, %Activity{} = activity, meta}} <-
	+ {:execute_side_effects, SideEffects.handle(activity, meta)},
	+ {_, {:ok, _}} <- {:federation, maybe_federate(activity, meta)} do
	+ {:ok, activity, meta}
	+ else
	+ {:mrf_object, {:reject, _}} -> {:ok, nil, meta}
	+ e -> {:error, e}
	+ end
	+ end
	+
	+ defp maybe_federate(activity, meta) do
	+ with {:ok, local} <- Keyword.fetch(meta, :local) do
	+ if local do
	+ Federator.publish(activity)
	+ {:ok, :federated}
	+ else
	+ {:ok, :not_federated}
	+ end
	+ else
	+ _e -> {:error, :badarg}
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	new file mode 100644
	index 000000000..666a4e310
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -0,0 +1,28 @@
	+defmodule Pleroma.Web.ActivityPub.SideEffects do
	+ @moduledoc """
	+ This module looks at an inserted object and executes the side effects that it
	+ implies. For example, a `Like` activity will increase the like count on the
	+ liked object, a `Follow` activity will add the user to the follower
	+ collection, and so on.
	+ """
	+ alias Pleroma.Notification
	+ alias Pleroma.Object
	+ alias Pleroma.Web.ActivityPub.Utils
	+
	+ def handle(object, meta \\ [])
	+
	+ # Tasks this handles:
	+ # - Add like to object
	+ # - Set up notification
	+ def handle(%{data: %{"type" => "Like"}} = object, meta) do
	+ liked_object = Object.get_by_ap_id(object.data["object"])
	+ Utils.add_like_to_object(object, liked_object)
	+ Notification.create_notifications(object)
	+ {:ok, object, meta}
	+ end
	+
	+ # Nothing to do
	+ def handle(object, meta) do
	+ {:ok, object, meta}
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 09bd9a442..0a8ad62ad 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1246 +1,1293 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.FollowingRelationship
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.ObjectValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	+ alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.TransmogrifierWorker

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object, options \\ []) do
	object
	\|> strip_internal_fields
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to(options)
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_addressing
	\|> fix_summary
	\|> fix_type(options)
	end

	def fix_summary(%{"summary" => nil} = object) do
	Map.put(object, "summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object), do: Map.put(object, "summary", "")

	def fix_addressing_list(map, field) do
	cond do
	is_binary(map[field]) ->
	Map.put(map, field, [map[field]])

	is_nil(map[field]) ->
	Map.put(map, field, [])

	true ->
	map
	end
	end

	def fix_explicit_addressing(
	%{"to" => to, "cc" => cc} = object,
	explicit_mentions,
	follower_collection
	) do
	explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)

	explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object), do: object

	def fix_explicit_addressing(object) do
	explicit_mentions = Utils.determine_explicit_mentions(object)

	%User{follower_address: follower_collection} =
	object
	\|> Containment.get_actor()
	\|> User.get_cached_by_ap_id()

	explicit_mentions =
	explicit_mentions ++
	[
	Pleroma.Constants.as_public(),
	follower_collection
	]

	fix_explicit_addressing(object, explicit_mentions, follower_collection)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	Pleroma.Constants.as_public() in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	Pleroma.Constants.as_public() in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_implicit_addressing(object, _), do: object

	def fix_addressing(object) do
	{:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
	followers_collection = User.ap_followers(user)

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_explicit_addressing()
	\|> fix_implicit_addressing(followers_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
	end

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
	depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(depth) do
	with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	else
	e ->
	Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	defp prepare_in_reply_to(in_reply_to) do
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	true ->
	""
	end
	end

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.put("conversation", context)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	Enum.map(attachment, fn data ->
	media_type = data["mediaType"] \|\| data["mimeType"]
	href = data["url"] \|\| data["href"]
	url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]

	data
	\|> Map.put("mediaType", media_type)
	\|> Map.put("url", url)
	end)

	Map.put(object, "attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	object
	\|> Map.put("attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	Map.put(object, "url", url["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type in ["Video", "Audio"] and is_list(url) do
	first_element = Enum.at(url, 0)

	link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)

	object
	\|> Map.put("attachment", [first_element])
	\|> Map.put("url", link_element["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type != "Video" and is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	Map.put(object, "url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji =
	tags
	\|> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	Map.put(mapping, name, data["icon"]["url"])
	end)

	# we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
	emoji = Map.merge(object["emoji"] \|\| %{}, emoji)

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)

	Map.put(object, "tag", tag ++ tags)
	end

	def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
	combined = [tag, String.slice(hashtag, 1..-1)]

	Map.put(object, "tag", combined)
	end

	def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	Map.put(object, "content", content)
	end

	def fix_content_map(object), do: object

	def fix_type(object, options \\ [])

	def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	with true <- Federator.allowed_thread_distance?(options[:depth]),
	{:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	def fix_type(object, _), do: object

	defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
	with true <- id =~ "follows",
	%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
	%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
	{:ok, activity}
	else
	_ -> {:error, nil}
	end
	end

	defp mastodon_follow_hack(_, _), do: {:error, nil}

	defp get_follow_activity(follow_object, followed) do
	with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
	{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
	{:ok, activity}
	else
	# Can't find the activity. This might a Mastodon 2.3 "Accept"
	{:activity, nil} ->
	mastodon_follow_hack(follow_object, followed)

	_ ->
	{:error, nil}
	end
	end

	# Reduce the object list to find the reported user.
	defp get_reported(objects) do
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end)
	end

	def handle_incoming(data, options \\ [])

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	# Reduce the object list to find the reported user.
	%User{} = account <- get_reported(objects),
	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{"cc" => [account.ap_id]}
	}
	\|> ActivityPub.flag()
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}, _options), do: :error
	def handle_incoming(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
	do: :error

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
	options
	)
	when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with nil <- Activity.get_create_by_object_ap_id(object["id"]),
	{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: object["conversation"],
	local: false,
	published: data["published"],
	additional:
	Map.take(data, [
	"cc",
	"directMessage",
	"id"
	])
	}

	with {:ok, created_activity} <- ActivityPub.create(params) do
	reply_depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(reply_depth) do
	for reply_id <- replies(object) do
	Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
	"id" => reply_id,
	"depth" => reply_depth
	})
	end
	end

	{:ok, created_activity}
	end
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
	options
	) do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	reply_depth = (options[:depth] \|\| 0) + 1
	options = Keyword.put(options, :depth, reply_depth)
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: nil,
	local: false,
	published: data["published"],
	additional: Map.take(data, ["cc", "id"])
	}

	ActivityPub.listen(params)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
	_options
	) do
	with %User{local: true} = followed <-
	User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
	{:ok, %User{} = follower} <-
	User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
	{:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
	with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
	{_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
	{_, false} <- {:user_locked, User.locked?(followed)},
	{_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
	{_, {:ok, _}} <-
	{:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})
	else
	{:user_blocked, true} ->
	{:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")

	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	{:follow, {:error, _}} ->
	{:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")

	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	{:user_locked, true} ->
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
	:noop
	end

	{:ok, activity}
	else
	_e ->
	:error
	end
	end

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	})
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
	{:ok, activity} <-
	ActivityPub.reject(%{
	to: follow_activity.data["to"],
	type: "Reject",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	}) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	@misskey_reactions %{
	"like" => "👍",
	"love" => "❤️",
	"laugh" => "😆",
	"hmm" => "🤔",
	"surprise" => "😮",
	"congrats" => "🎉",
	"angry" => "💢",
	"confused" => "😥",
	"rip" => "😇",
	"pudding" => "🍮",
	"star" => "⭐"
	}

	@doc "Rewrite misskey likes into EmojiReacts"
	def handle_incoming(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming(options)
	end

	- def handle_incoming(
	- %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
	- _options
	- ) do
	- with actor <- Containment.get_actor(data),
	- {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id),
	- {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
	+ def handle_incoming(%{"type" => "Like"} = data, _options) do
	+ with {_, {:ok, cast_data_sym}} <-
	+ {:casting_data,
	+ data \|> LikeValidator.cast_data() \|> Ecto.Changeset.apply_action(:insert)},
	+ cast_data = ObjectValidator.stringify_keys(Map.from_struct(cast_data_sym)),
	+ :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
	+ {_, {:ok, cast_data}} <- {:ensure_context_presence, ensure_context_presence(cast_data)},
	+ {_, {:ok, cast_data}} <-
	+ {:ensure_recipients_presence, ensure_recipients_presence(cast_data)},
	+ {_, {:ok, activity, _meta}} <-
	+ {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
	{:ok, activity}
	else
	- _e -> :error
	+ e -> {:error, e}
	end
	end

	def handle_incoming(
	%{
	"type" => "EmojiReact",
	"object" => object_id,
	"actor" => _actor,
	"id" => id,
	"content" => emoji
	} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _object} <-
	ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_embedded_obj_helper(object_id, actor),
	public <- Visibility.is_public?(data),
	{:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
	data,
	_options
	)
	when object_type in [
	"Person",
	"Application",
	"Service",
	"Organization"
	] do
	with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

	actor
	\|> User.upgrade_changeset(new_user_data, true)
	\|> User.update_and_set_cache()

	ActivityPub.update(%{
	local: false,
	to: data["to"] \|\| [],
	cc: data["cc"] \|\| [],
	object: object,
	actor: actor_id,
	activity_id: data["id"]
	})
	else
	e ->
	Logger.error(e)
	:error
	end
	end

	# TODO: We presently assume that any actor on the same origin domain as the object being
	# deleted has the rights to delete that object. A better way to validate whether or not
	# the object should be deleted is to refetch the object URI, which should return either
	# an error or a tombstone. This would allow us to verify that a deletion actually took
	# place.
	def handle_incoming(
	%{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
	_options
	) do
	object_id = Utils.get_ap_id(object_id)

	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id),
	:ok <- Containment.contain_origin(actor.ap_id, object.data),
	{:ok, activity} <-
	ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
	{:ok, activity}
	else
	nil ->
	case User.get_cached_by_ap_id(object_id) do
	%User{ap_id: ^actor} = user ->
	User.delete(user)

	nil ->
	:error
	end

	_e ->
	:error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Announce", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
	"actor" => _actor,
	"id" => id
	} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, activity, _} <-
	ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
	activity_id: id,
	local: false
	) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Block", "object" => blocked},
	"actor" => blocker,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
	User.unblock(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
	_options
	) do
	with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
	{:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
	User.unfollow(blocker, blocked)
	User.block(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Like", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	# For Undos that don't have the complete object attached, try to find it in our database.
	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => object
	} = activity,
	options
	)
	when is_binary(object) do
	with %Activity{data: data} <- Activity.get_by_ap_id(object) do
	activity
	\|> Map.put("object", data)
	\|> handle_incoming(options)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Move",
	"actor" => origin_actor,
	"object" => origin_actor,
	"target" => target_actor
	},
	_options
	) do
	with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
	true <- origin_actor in target_user.also_known_as do
	ActivityPub.move(origin_user, target_user, false)
	else
	_e -> :error
	end
	end

	def handle_incoming(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	case Object.normalize(id, true, options) do
	%Object{} = object -> {:ok, object}
	_ -> nil
	end
	end

	@spec get_embedded_obj_helper(String.t() \| Object.t(), User.t()) :: {:ok, Object.t()} \| nil
	def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
	ap_id: ap_id
	})
	when attributed_to == ap_id do
	with {:ok, activity} <-
	handle_incoming(%{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => attributed_to,
	"object" => data
	}) do
	{:ok, Object.normalize(activity)}
	else
	_ -> get_obj_helper(object_id)
	end
	end

	def get_embedded_obj_helper(object_id, _) do
	get_obj_helper(object_id)
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	@doc """
	Serialized Mastodon-compatible `replies` collection containing _self-replies_.
	Based on Mastodon's ActivityPub::NoteSerializer#replies.
	"""
	def set_replies(obj_data) do
	replies_uris =
	with limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	%Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
	object
	\|> Object.self_replies()
	\|> select([o], fragment("?->>'id'", o.data))
	\|> limit(^limit)
	\|> Repo.all()
	else
	_ -> []
	end

	set_replies(obj_data, replies_uris)
	end

	defp set_replies(obj, []) do
	obj
	end

	defp set_replies(obj, replies_uris) do
	replies_collection = %{
	"type" => "Collection",
	"items" => replies_uris
	}

	Map.merge(obj, %{"replies" => replies_collection})
	end

	def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
	items
	end

	def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
	items
	end

	def replies(_), do: []

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> set_sensitive
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> set_replies
	\|> strip_internal_fields
	\|> strip_internal_tags
	\|> set_type
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
	when activity_type in ["Create", "Listen"] do
	object =
	object_id
	\|> Object.normalize()
	\|> Map.get(:data)
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
	object =
	object_id
	\|> Object.normalize()

	data =
	if Visibility.is_private?(object) && object.data["actor"] == ap_id do
	data \|> Map.put("object", object \|> Map.get(:data) \|> prepare_object)
	else
	data \|> maybe_fix_object_url
	end

	data =
	data
	\|> strip_internal_fields
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
	with false <- String.starts_with?(object, "http"),
	{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
	%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
	relative_object do
	Map.put(data, "object", external_url)
	else
	{:fetch, e} ->
	Logger.error("Couldn't fetch #{object} #{inspect(e)}")
	data

	_ ->
	data
	end
	end

	def maybe_fix_object_url(data), do: data

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

	Map.put(object, "tag", tags)
	end

	def add_mention_tags(object) do
	{enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
	potential_receivers = enabled_receivers ++ disabled_receivers
	mentions = Enum.map(potential_receivers, &build_mention_tag/1)

	tags = object["tag"] \|\| []
	Map.put(object, "tag", tags ++ mentions)
	end

	defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
	%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
	end

	def take_emoji_tags(%User{emoji: emoji}) do
	emoji
	\|> Enum.flat_map(&Map.to_list/1)
	\|> Enum.map(&build_emoji_tag/1)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(%{"emoji" => emoji} = object) do
	tags = object["tag"] \|\| []

	out = Enum.map(emoji, &build_emoji_tag/1)

	Map.put(object, "tag", tags ++ out)
	end

	def add_emoji_tags(object), do: object

	defp build_emoji_tag({name, url}) do
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_sensitive(object) do
	tags = object["tag"] \|\| []
	Map.put(object, "sensitive", "nsfw" in tags)
	end

	def set_type(%{"type" => "Answer"} = object) do
	Map.put(object, "type", "Note")
	end

	def set_type(object), do: object

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]
	Map.put(object, "attributedTo", attributed_to)
	end

	def prepare_attachments(object) do
	attachments =
	(object["attachment"] \|\| [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} \| _] = data["url"]
	%{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
	end)

	Map.put(object, "attachment", attachments)
	end

	def strip_internal_fields(object) do
	object
	\|> Map.drop(Pleroma.Constants.object_internal_fields())
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags = Enum.filter(tags, fn x -> is_map(x) end)

	Map.put(object, "tag", tags)
	end

	defp strip_internal_tags(object), do: object

	def perform(:user_upgrade, user) do
	# we pass a fake user so that the followers collection is stripped away
	old_follower_address = User.ap_followers(%User{nickname: user.nickname})

	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)
	\|> Repo.update_all([])
	end

	def upgrade_user_from_ap_id(ap_id) do
	with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	already_ap <- User.ap_enabled?(user),
	{:ok, user} <- upgrade_user(user, data) do
	if not already_ap do
	TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
	end

	{:ok, user}
	else
	%User{} = user -> {:ok, user}
	e -> e
	end
	end

	defp upgrade_user(user, data) do
	user
	\|> User.upgrade_changeset(data, true)
	\|> User.update_and_set_cache()
	end

	def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	+
	+ defp ensure_context_presence(%{"context" => context} = data) when is_binary(context),
	+ do: {:ok, data}
	+
	+ defp ensure_context_presence(%{"object" => object} = data) when is_binary(object) do
	+ with %{data: %{"context" => context}} when is_binary(context) <- Object.normalize(object) do
	+ {:ok, Map.put(data, "context", context)}
	+ else
	+ _ ->
	+ {:error, :no_context}
	+ end
	+ end
	+
	+ defp ensure_context_presence(_) do
	+ {:error, :no_context}
	+ end
	+
	+ defp ensure_recipients_presence(%{"to" => [_ \| _], "cc" => [_ \| _]} = data),
	+ do: {:ok, data}
	+
	+ defp ensure_recipients_presence(%{"object" => object} = data) do
	+ case Object.normalize(object) do
	+ %{data: %{"actor" => actor}} ->
	+ data =
	+ data
	+ \|> Map.put("to", [actor])
	+ \|> Map.put("cc", data["cc"] \|\| [])
	+
	+ {:ok, data}
	+
	+ nil ->
	+ {:error, :no_object}
	+
	+ _ ->
	+ {:error, :no_actor}
	+ end
	+ end
	+
	+ defp ensure_recipients_presence(_) do
	+ {:error, :no_object}
	+ end
	end
	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index 2646b9f7b..636cf3301 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,445 +1,481 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.Conversation.Participation
	alias Pleroma.FollowingRelationship
	alias Pleroma.Object
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.Builder
	+ alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Pleroma.Web.Gettext
	import Pleroma.Web.CommonAPI.Utils

	require Pleroma.Constants
	+ require Logger

	def follow(follower, followed) do
	timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])

	with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
	{:ok, follower, followed, activity}
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
	{:ok, _subscription} <- User.unsubscribe(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with {:ok, follower} <- User.follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept"),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with {_, %Activity{data: %{"object" => _}} = activity} <-
	{:find_activity, Activity.get_by_id_with_object(activity_id)},
	%Object{} = object <- Object.normalize(activity),
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not delete")}
	end
	end

	def repeat(id_or_ap_id, user, params \\ %{}) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)},
	object <- Object.normalize(activity),
	announce_activity <- Utils.get_existing_announce(user.ap_id, object),
	public <- public_announce?(object, params) do
	if announce_activity do
	{:ok, announce_activity, object}
	else
	ActivityPub.announce(user, object, nil, true, public)
	end
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not repeat")}
	end
	end

	def unrepeat(id_or_ap_id, user) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)} do
	object = Object.normalize(activity)
	ActivityPub.unannounce(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unrepeat")}
	end
	end

	- def favorite(id_or_ap_id, user) do
	- with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)},
	- object <- Object.normalize(activity),
	- like_activity <- Utils.get_existing_like(user.ap_id, object) do
	- if like_activity do
	- {:ok, like_activity, object}
	- else
	- ActivityPub.like(user, object)
	- end
	+ @spec favorite(User.t(), binary()) :: {:ok, Activity.t() \| :already_liked} \| {:error, any()}
	+ def favorite(%User{} = user, id) do
	+ case favorite_helper(user, id) do
	+ {:ok, _} = res ->
	+ res
	+
	+ {:error, :not_found} = res ->
	+ res
	+
	+ {:error, e} ->
	+ Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
	+ {:error, dgettext("errors", "Could not favorite")}
	+ end
	+ end
	+
	+ def favorite_helper(user, id) do
	+ with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
	+ {_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	+ {_, {:ok, %Activity{} = activity, _meta}} <-
	+ {:common_pipeline,
	+ Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	+ {:ok, activity}
	else
	- {:find_activity, _} -> {:error, :not_found}
	- _ -> {:error, dgettext("errors", "Could not favorite")}
	+ {:find_object, _} ->
	+ {:error, :not_found}
	+
	+ {:common_pipeline,
	+ {
	+ :error,
	+ {
	+ :validate_object,
	+ {
	+ :error,
	+ changeset
	+ }
	+ }
	+ }} = e ->
	+ if {:object, {"already liked by this actor", []}} in changeset.errors do
	+ {:ok, :already_liked}
	+ else
	+ {:error, e}
	+ end
	+
	+ e ->
	+ {:error, e}
	end
	end

	def unfavorite(id_or_ap_id, user) do
	with {_, %Activity{} = activity} <- {:find_activity, get_by_id_or_ap_id(id_or_ap_id)} do
	object = Object.normalize(activity)
	ActivityPub.unlike(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unfavorite")}
	end
	end

	def react_with_emoji(id, user, emoji) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	object <- Object.normalize(activity) do
	ActivityPub.react_with_emoji(user, object, emoji)
	else
	_ ->
	{:error, dgettext("errors", "Could not add reaction emoji")}
	end
	end

	def unreact_with_emoji(id, user, emoji) do
	with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji) do
	ActivityPub.unreact_with_emoji(user, reaction_activity.data["id"])
	else
	_ ->
	{:error, dgettext("errors", "Could not remove reaction emoji")}
	end
	end

	def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
	with :ok <- validate_not_author(object, user),
	:ok <- validate_existing_votes(user, object),
	{:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
	answer_activities =
	Enum.map(choices, fn index ->
	answer_data = make_answer_data(user, object, Enum.at(options, index)["name"])

	{:ok, activity} =
	ActivityPub.create(%{
	to: answer_data["to"],
	actor: user,
	context: object.data["context"],
	object: answer_data,
	additional: %{"cc" => answer_data["cc"]}
	})

	activity
	end)

	object = Object.get_cached_by_ap_id(object.data["id"])
	{:ok, answer_activities, object}
	end
	end

	defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
	do: {:error, dgettext("errors", "Poll's author can't vote")}

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

	defp validate_existing_votes(%{ap_id: ap_id}, object) do
	if Utils.get_existing_votes(ap_id, object) == [] do
	:ok
	else
	{:error, dgettext("errors", "Already voted")}
	end
	end

	defp get_options_and_max_count(%{data: %{"anyOf" => any_of}}), do: {any_of, Enum.count(any_of)}
	defp get_options_and_max_count(%{data: %{"oneOf" => one_of}}), do: {one_of, 1}

	defp normalize_and_validate_choices(choices, object) do
	choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
	{options, max_count} = get_options_and_max_count(object)
	count = Enum.count(options)

	with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
	{_, true} <- {:count_check, Enum.count(choices) <= max_count} do
	{:ok, options, choices}
	else
	{:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
	{:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
	end
	end

	def public_announce?(_, %{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility in ~w(public unlisted)

	def public_announce?(object, _) do
	Visibility.is_public?(object)
	end

	def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}

	def get_visibility(%{"visibility" => visibility}, in_reply_to, _)
	when visibility in ~w{public unlisted private direct},
	do: {visibility, get_replied_to_visibility(in_reply_to)}

	def get_visibility(%{"visibility" => "list:" <> list_id}, in_reply_to, _) do
	visibility = {:list, String.to_integer(list_id)}
	{visibility, get_replied_to_visibility(in_reply_to)}
	end

	def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
	visibility = get_replied_to_visibility(in_reply_to)
	{visibility, visibility}
	end

	def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}

	def get_replied_to_visibility(nil), do: nil

	def get_replied_to_visibility(activity) do
	with %Object{} = object <- Object.normalize(activity) do
	Visibility.get_visibility(object)
	end
	end

	def check_expiry_date({:ok, nil} = res), do: res

	def check_expiry_date({:ok, in_seconds}) do
	expiry = NaiveDateTime.utc_now() \|> NaiveDateTime.add(in_seconds)

	if ActivityExpiration.expires_late_enough?(expiry) do
	{:ok, expiry}
	else
	{:error, "Expiry date is too soon"}
	end
	end

	def check_expiry_date(expiry_str) do
	Ecto.Type.cast(:integer, expiry_str)
	\|> check_expiry_date()
	end

	def listen(user, %{"title" => _} = data) do
	with visibility <- data["visibility"] \|\| "public",
	{to, cc} <- get_to_and_cc(user, [], nil, visibility, nil),
	listen_data <-
	Map.take(data, ["album", "artist", "title", "length"])
	\|> Map.put("type", "Audio")
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	\|> Map.put("actor", user.ap_id),
	{:ok, activity} <-
	ActivityPub.listen(%{
	actor: user,
	to: to,
	object: listen_data,
	context: Utils.generate_context_id(),
	additional: %{"cc" => cc}
	}) do
	{:ok, activity}
	end
	end

	def post(user, %{"status" => _} = data) do
	with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do
	draft.changes
	\|> ActivityPub.create(draft.preview?)
	\|> maybe_create_activity_expiration(draft.expires_at)
	end
	end

	defp maybe_create_activity_expiration({:ok, activity}, %NaiveDateTime{} = expires_at) do
	with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(result, _), do: result

	# Updates the emojis for a user based on their profile
	def update(user) do
	emoji = emoji_from_profile(user)
	source_data = Map.put(user.source_data, "tag", emoji)

	user =
	case User.update_source_data(user, source_data) do
	{:ok, user} -> user
	_ -> user
	end

	ActivityPub.update(%{
	local: true,
	to: [Pleroma.Constants.as_public(), user.follower_address],
	cc: [],
	actor: user.ap_id,
	object: Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	})
	end

	def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{"type" => "Create"},
	object: %Object{data: %{"type" => object_type}}
	} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	true <- object_type in ["Note", "Article", "Question"],
	true <- Visibility.is_public?(activity),
	{:ok, _user} <- User.add_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not pin")}
	end
	end

	def unpin(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	{:ok, _user} <- User.remove_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not unpin")}
	end
	end

	def add_mute(user, activity) do
	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
	{:ok, activity}
	else
	{:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
	end
	end

	def remove_mute(user, activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def thread_muted?(%{id: nil} = _user, _activity), do: false

	def thread_muted?(user, activity) do
	ThreadMute.exists?(user.id, activity.data["context"])
	end

	def report(user, %{"account_id" => account_id} = data) do
	with {:ok, account} <- get_reported_account(account_id),
	{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
	{:ok, statuses} <- get_report_statuses(account, data) do
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: data["forward"] \|\| false
	})
	end
	end

	def report(_user, _params), do: {:error, dgettext("errors", "Valid `account_id` required")}

	defp get_reported_account(account_id) do
	case User.get_cached_by_id(account_id) do
	%User{} = account -> {:ok, account}
	_ -> {:error, dgettext("errors", "Account not found")}
	end
	end

	def update_report_state(activity_ids, state) when is_list(activity_ids) do
	case Utils.update_report_state(activity_ids, state) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_report_state(activity_id, state) do
	with %Activity{} = activity <- Activity.get_by_id(activity_id) do
	Utils.update_report_state(activity, state)
	else
	nil -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_activity_scope(activity_id, opts \\ %{}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	{:ok, activity} <- toggle_sensitive(activity, opts) do
	set_visibility(activity, opts)
	else
	nil -> {:error, :not_found}
	{:error, reason} -> {:error, reason}
	end
	end

	defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do
	toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)})
	end

	defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive})
	when is_boolean(sensitive) do
	new_data = Map.put(object.data, "sensitive", sensitive)

	{:ok, object} =
	object
	\|> Object.change(%{data: new_data})
	\|> Object.update_and_set_cache()

	{:ok, Map.put(activity, :object, object)}
	end

	defp toggle_sensitive(activity, _), do: {:ok, activity}

	defp set_visibility(activity, %{"visibility" => visibility}) do
	Utils.update_activity_visibility(activity, visibility)
	end

	defp set_visibility(activity, _), do: {:ok, activity}

	def hide_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.create_reblog_mute(user, target)
	end

	def show_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.delete_reblog_mute(user, target)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	index 37afe6949..ec8f0d8a0 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	@@ -1,383 +1,383 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Pleroma.Web.ControllerHelper, only: [try_render: 3, add_link_headers: 2]

	require Ecto.Query

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Object
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView

	@unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:statuses"]}
	when action in [
	:index,
	:show,
	:card,
	:context
	]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:statuses"]}
	when action in [
	:create,
	:delete,
	:reblog,
	:unreblog
	]
	)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:favourites"]} when action in [:favourite, :unfavourite]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:mutes"]} when action in [:mute_conversation, :unmute_conversation]
	)

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:accounts"]}
	when action in [:favourited_by, :reblogged_by]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action in [:pin, :unpin])

	# Note: scope not present in Mastodon: read:bookmarks
	plug(OAuthScopesPlug, %{scopes: ["read:bookmarks"]} when action == :bookmarks)

	# Note: scope not present in Mastodon: write:bookmarks
	plug(
	OAuthScopesPlug,
	%{scopes: ["write:bookmarks"]} when action in [:bookmark, :unbookmark]
	)

	plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug when action not in [:index, :show])

	@rate_limited_status_actions ~w(reblog unreblog favourite unfavourite create delete)a

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:reblog_unreblog", params: ["id"]]
	when action in ~w(reblog unreblog)a
	)

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]]
	when action in ~w(favourite unfavourite)a
	)

	plug(RateLimiter, [name: :statuses_actions] when action in @rate_limited_status_actions)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	@doc """
	GET `/api/v1/statuses?ids[]=1&ids[]=2`

	`ids` query param is required
	"""
	def index(%{assigns: %{user: user}} = conn, %{"ids" => ids}) do
	limit = 100

	activities =
	ids
	\|> Enum.take(limit)
	\|> Activity.all_by_ids_with_object()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))

	render(conn, "index.json", activities: activities, for: user, as: :activity)
	end

	@doc """
	POST /api/v1/statuses

	Creates a scheduled status when `scheduled_at` param is present and it's far enough
	"""
	def create(
	%{assigns: %{user: user}} = conn,
	%{"status" => _, "scheduled_at" => scheduled_at} = params
	) do
	params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])

	with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)},
	attrs <- %{"params" => params, "scheduled_at" => scheduled_at},
	{:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", scheduled_activity: scheduled_activity)
	else
	{:far_enough, _} ->
	create(conn, Map.drop(params, ["scheduled_at"]))

	error ->
	error
	end
	end

	@doc """
	POST /api/v1/statuses

	Creates a regular status
	"""
	def create(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
	params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])

	with {:ok, activity} <- CommonAPI.post(user, params) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	as: :activity,
	with_direct_conversation_id: true
	)
	else
	{:error, message} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})
	end
	end

	def create(%{assigns: %{user: _user}} = conn, %{"media_ids" => _} = params) do
	create(conn, Map.put(params, "status", ""))
	end

	@doc "GET /api/v1/statuses/:id"
	def show(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "DELETE /api/v1/statuses/:id"
	def delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	else
	{:error, :not_found} = e -> e
	_e -> render_error(conn, :forbidden, "Can't delete this post")
	end
	end

	@doc "POST /api/v1/statuses/:id/reblog"
	def reblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id} = params) do
	with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user, params),
	%Activity{} = announce <- Activity.normalize(announce.data) do
	try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/unreblog"
	def unreblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
	try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/favourite"
	- def favourite(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	- with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	+ def favourite(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
	+ with {:ok, _fav} <- CommonAPI.favorite(user, activity_id),
	+ %Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unfavourite"
	def unfavourite(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/pin"
	def pin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unpin"
	def unpin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/bookmark"
	def bookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.create(user.id, activity.id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unbookmark"
	def unbookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/mute"
	def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.add_mute(user, activity) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unmute"
	def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.remove_mute(user, activity) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "GET /api/v1/statuses/:id/card"
	@deprecated "https://github.com/tootsuite/mastodon/pull/11213"
	def card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
	with %Activity{} = activity <- Activity.get_by_id(status_id),
	true <- Visibility.visible_for_user?(activity, user) do
	data = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	render(conn, "card.json", data)
	else
	_ -> render_error(conn, :not_found, "Record not found")
	end
	end

	@doc "GET /api/v1/statuses/:id/favourited_by"
	def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"likes" => likes}} <- Object.normalize(activity) do
	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^likes)
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/reblogged_by"
	def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"announcements" => announces, "id" => ap_id}} <-
	Object.normalize(activity) do
	announces =
	"Announce"
	\|> Activity.Queries.by_type()
	\|> Ecto.Query.where([a], a.actor in ^announces)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.all()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))
	\|> Enum.map(& &1.actor)
	\|> Enum.uniq()

	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^announces)
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/context"
	def context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id) do
	activities =
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	"blocking_user" => user,
	"user" => user,
	"exclude_id" => activity.id
	})

	render(conn, "context.json", activity: activity, activities: activities, user: user)
	end
	end

	@doc "GET /api/v1/favourites"
	def favourites(%{assigns: %{user: user}} = conn, params) do
	activities =
	ActivityPub.fetch_favourites(
	user,
	Map.take(params, Pleroma.Pagination.page_keys())
	)

	conn
	\|> add_link_headers(activities)
	\|> render("index.json", activities: activities, for: user, as: :activity)
	end

	@doc "GET /api/v1/bookmarks"
	def bookmarks(%{assigns: %{user: user}} = conn, params) do
	user = User.get_cached_by_id(user.id)

	bookmarks =
	user.id
	\|> Bookmark.for_user_query()
	\|> Pleroma.Pagination.fetch_paginated(params)

	activities =
	bookmarks
	\|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)

	conn
	\|> add_link_headers(bookmarks)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index c482bba64..99e62f580 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,350 +1,352 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.FollowingRelationship
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("index.json", %{users: users} = opts) do
	+ reading_user = opts[:for]
	+
	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	- is_nil(opts[:for]) ->
	+ is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	- UserRelationship.view_relationships_option(opts[:for], users)
	+ UserRelationship.view_relationships_option(reading_user, users)
	end

	opts = Map.put(opts, :relationships, relationships_opt)

	users
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

	def render("show.json", %{user: user} = opts) do
	if User.visible_for?(user, opts[:for]),
	do: do_render("show.json", opts),
	else: %{}
	end

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: user.uri \|\| user.ap_id
	}
	end

	def render("relationship.json", %{user: nil, target: _target}) do
	%{}
	end

	def render(
	"relationship.json",
	%{user: %User{} = reading_user, target: %User{} = target} = opts
	) do
	user_relationships = get_in(opts, [:relationships, :user_relationships])
	following_relationships = get_in(opts, [:relationships, :following_relationships])

	follow_state =
	if following_relationships do
	user_to_target_following_relation =
	FollowingRelationship.find(following_relationships, reading_user, target)

	User.get_follow_state(reading_user, target, user_to_target_following_relation)
	else
	User.get_follow_state(reading_user, target)
	end

	followed_by =
	if following_relationships do
	case FollowingRelationship.find(following_relationships, target, reading_user) do
	%{state: "accept"} -> true
	_ -> false
	end
	else
	User.following?(target, reading_user)
	end

	# NOTE: adjust UserRelationship.view_relationships_option/2 on new relation-related flags
	%{
	id: to_string(target.id),
	following: follow_state == "accept",
	followed_by: followed_by,
	blocking:
	UserRelationship.exists?(
	user_relationships,
	:block,
	reading_user,
	target,
	&User.blocks_user?(&1, &2)
	),
	blocked_by:
	UserRelationship.exists?(
	user_relationships,
	:block,
	target,
	reading_user,
	&User.blocks_user?(&1, &2)
	),
	muting:
	UserRelationship.exists?(
	user_relationships,
	:mute,
	reading_user,
	target,
	&User.mutes?(&1, &2)
	),
	muting_notifications:
	UserRelationship.exists?(
	user_relationships,
	:notification_mute,
	reading_user,
	target,
	&User.muted_notifications?(&1, &2)
	),
	subscribing:
	UserRelationship.exists?(
	user_relationships,
	:inverse_subscription,
	target,
	reading_user,
	&User.subscribed_to?(&2, &1)
	),
	requested: follow_state == "pending",
	domain_blocking: User.blocks_domain?(reading_user, target),
	showing_reblogs:
	not UserRelationship.exists?(
	user_relationships,
	:reblog_mute,
	reading_user,
	target,
	&User.muting_reblogs?(&1, &2)
	),
	endorsed: false
	}
	end

	def render("relationships.json", %{user: user, targets: targets} = opts) do
	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	- is_nil(opts[:for]) ->
	+ is_nil(user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	UserRelationship.view_relationships_option(user, targets)
	end

	render_opts = %{as: :target, user: user, relationships: relationships_opt}
	render_many(targets, AccountView, "relationship.json", render_opts)
	end

	defp do_render("show.json", %{user: user} = opts) do
	user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
	display_name = user.name \|\| user.nickname

	image = User.avatar_url(user) \|> MediaProxy.url()
	header = User.banner_url(user) \|> MediaProxy.url()

	following_count =
	if !user.hide_follows_count or !user.hide_follows or opts[:for] == user do
	user.following_count \|\| 0
	else
	0
	end

	followers_count =
	if !user.hide_followers_count or !user.hide_followers or opts[:for] == user do
	user.follower_count \|\| 0
	else
	0
	end

	bot = user.actor_type in ["Application", "Service"]

	emojis =
	(user.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	%{
	"shortcode" => String.trim(name, ":"),
	"url" => MediaProxy.url(url),
	"static_url" => MediaProxy.url(url),
	"visible_in_picker" => false
	}
	end)

	relationship =
	render("relationship.json", %{
	user: opts[:for],
	target: user,
	relationships: opts[:relationships]
	})

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: display_name,
	locked: user.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: followers_count,
	following_count: following_count,
	statuses_count: user.note_count,
	note: user.bio \|\| "",
	url: user.uri \|\| user.ap_id,
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: user.fields,
	bot: bot,
	source: %{
	note: (user.bio \|\| "") \|> String.replace(~r(<br */?>), "\n") \|> Pleroma.HTML.strip_tags(),
	sensitive: false,
	fields: user.raw_fields,
	pleroma: %{
	discoverable: user.discoverable,
	actor_type: user.actor_type
	}
	},

	# Pleroma extension
	pleroma: %{
	confirmation_pending: user.confirmation_pending,
	tags: user.tags,
	hide_followers_count: user.hide_followers_count,
	hide_follows_count: user.hide_follows_count,
	hide_followers: user.hide_followers,
	hide_follows: user.hide_follows,
	hide_favorites: user.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.skip_thread_containment,
	background_image: image_url(user.background) \|> MediaProxy.url()
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], opts)
	\|> maybe_put_notification_settings(user, opts[:for])
	\|> maybe_put_settings_store(user, opts[:for], opts)
	\|> maybe_put_chat_token(user, opts[:for], opts)
	\|> maybe_put_activation_status(user, opts[:for])
	\|> maybe_put_follow_requests_count(user, opts[:for])
	\|> maybe_put_allow_following_move(user, opts[:for])
	\|> maybe_put_unread_conversation_count(user, opts[:for])
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

	defp maybe_put_follow_requests_count(
	data,
	%User{id: user_id} = user,
	%User{id: user_id}
	) do
	count =
	User.get_follow_requests(user)
	\|> length()

	data
	\|> Kernel.put_in([:follow_requests_count], count)
	end

	defp maybe_put_follow_requests_count(data, _, _), do: data

	defp maybe_put_settings(
	data,
	%User{id: user_id} = user,
	%User{id: user_id},
	_opts
	) do
	data
	\|> Kernel.put_in([:source, :privacy], user.default_scope)
	\|> Kernel.put_in([:source, :pleroma, :show_role], user.show_role)
	\|> Kernel.put_in([:source, :pleroma, :no_rich_text], user.no_rich_text)
	end

	defp maybe_put_settings(data, _, _, _), do: data

	defp maybe_put_settings_store(data, %User{} = user, %User{}, %{
	with_pleroma_settings: true
	}) do
	data
	\|> Kernel.put_in([:pleroma, :settings_store], user.pleroma_settings_store)
	end

	defp maybe_put_settings_store(data, _, _, _), do: data

	defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
	with_chat_token: token
	}) do
	data
	\|> Kernel.put_in([:pleroma, :chat_token], token)
	end

	defp maybe_put_chat_token(data, _, _, _), do: data

	defp maybe_put_role(data, %User{show_role: true} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	end

	defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	end

	defp maybe_put_role(data, _, _), do: data

	defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(data, [:pleroma, :notification_settings], user.notification_settings)
	end

	defp maybe_put_notification_settings(data, _, _), do: data

	defp maybe_put_allow_following_move(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(data, [:pleroma, :allow_following_move], user.allow_following_move)
	end

	defp maybe_put_allow_following_move(data, _, _), do: data

	defp maybe_put_activation_status(data, user, %User{is_admin: true}) do
	Kernel.put_in(data, [:pleroma, :deactivated], user.deactivated)
	end

	defp maybe_put_activation_status(data, _, _), do: data

	defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in(
	[:pleroma, :unread_conversation_count],
	user.unread_conversation_count
	)
	end

	defp maybe_put_unread_conversation_count(data, _, _), do: data

	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/notification_view.ex b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	index 89f5734ff..ae87d4701 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,150 +1,150 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView

	def render("index.json", %{notifications: notifications, for: reading_user} = opts) do
	activities = Enum.map(notifications, & &1.activity)

	parent_activities =
	activities
	\|> Enum.filter(
	&(Activity.mastodon_notification_type(&1) in [
	"favourite",
	"reblog",
	"pleroma:emoji_reaction"
	])
	)
	\|> Enum.map(& &1.data["object"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Pleroma.Repo.all()

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

	- is_nil(opts[:for]) ->
	+ is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	move_activities_targets =
	activities
	\|> Enum.filter(&(Activity.mastodon_notification_type(&1) == "move"))
	\|> Enum.map(&User.get_cached_by_ap_id(&1.data["target"]))

	actors =
	activities
	\|> Enum.map(fn a -> User.get_cached_by_ap_id(a.data["actor"]) end)
	\|> Enum.filter(& &1)
	\|> Kernel.++(move_activities_targets)

	UserRelationship.view_relationships_option(reading_user, actors)
	end

	opts = %{
	for: reading_user,
	parent_activities: parent_activities,
	relationships: relationships_opt
	}

	safe_render_many(notifications, NotificationView, "show.json", opts)
	end

	def render(
	"show.json",
	%{
	notification: %Notification{activity: activity} = notification,
	for: reading_user
	} = opts
	) do
	actor = User.get_cached_by_ap_id(activity.data["actor"])

	parent_activity_fn = fn ->
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(opts[:parent_activities], activity.data["object"])
	else
	Activity.get_create_by_object_ap_id(activity.data["object"])
	end
	end

	mastodon_type = Activity.mastodon_notification_type(activity)

	with %{id: _} = account <-
	AccountView.render("show.json", %{
	user: actor,
	for: reading_user,
	relationships: opts[:relationships]
	}) do
	response = %{
	id: to_string(notification.id),
	type: mastodon_type,
	created_at: CommonAPI.Utils.to_masto_date(notification.inserted_at),
	account: account,
	pleroma: %{
	is_seen: notification.seen
	}
	}

	render_opts = %{relationships: opts[:relationships]}

	case mastodon_type do
	"mention" ->
	put_status(response, activity, reading_user, render_opts)

	"favourite" ->
	put_status(response, parent_activity_fn.(), reading_user, render_opts)

	"reblog" ->
	put_status(response, parent_activity_fn.(), reading_user, render_opts)

	"move" ->
	put_target(response, activity, reading_user, render_opts)

	"follow" ->
	response

	"pleroma:emoji_reaction" ->
	response
	\|> put_status(parent_activity_fn.(), reading_user, render_opts)
	\|> put_emoji(activity)

	_ ->
	nil
	end
	else
	_ -> nil
	end
	end

	defp put_emoji(response, activity) do
	Map.put(response, :emoji, activity.data["content"])
	end

	defp put_status(response, activity, reading_user, opts) do
	status_render_opts = Map.merge(opts, %{activity: activity, for: reading_user})
	status_render = StatusView.render("show.json", status_render_opts)

	Map.put(response, :status, status_render)
	end

	defp put_target(response, activity, reading_user, opts) do
	target_user = User.get_cached_by_ap_id(activity.data["target"])
	target_render_opts = Map.merge(opts, %{user: target_user, for: reading_user})
	target_render = AccountView.render("show.json", target_render_opts)

	Map.put(response, :target, target_render)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 82326986c..cea76e735 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,562 +1,564 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy

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

	# 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)
	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)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_user(ap_id) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
	do: Utils.context_to_conversation_id(context)

	defp get_context_id(_), do: nil

	defp reblogged?(activity, user) do
	object = Object.normalize(activity) \|\| %{}
	present?(user && user.ap_id in (object.data["announcements"] \|\| []))
	end

	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)
	replied_to_activities = get_replied_to_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	- \|> Activity.with_preloaded_bookmark(opts[:for])
	- \|> Activity.with_set_thread_muted_field(opts[:for])
	+ \|> 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(opts[:for]) ->
	+ is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	actors = Enum.map(activities ++ parent_activities, &get_user(&1.data["actor"]))

	- UserRelationship.view_relationships_option(opts[:for], actors)
	+ UserRelationship.view_relationships_option(reading_user, actors)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_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 = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	activity_object = Object.normalize(activity)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	activity_object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(activity_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 (activity_object.data["likes"] \|\| [])

	bookmarked = Activity.get_bookmark(reblogged_parent_activity, opts[:for]) != nil

	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)

	%{
	id: to_string(activity.id),
	uri: activity_object.data["id"],
	url: activity_object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for],
	relationships: opts[:relationships]
	}),
	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?(bookmarked),
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local
	}
	}
	end

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

	user = 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

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

	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"] \|\| [])

	bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil

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

	expires_at =
	with true <- client_posted_this_activity,
	%ActivityExpiration{scheduled_at: scheduled_at} <-
	ActivityExpiration.get_by_activity_id(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"])

	reply_to = get_reply_to(activity, opts)

	reply_to_user = reply_to && get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()

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

	content_plaintext =
	content
	\|> HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content"
	)

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

	card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))

	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 =
	with %{data: %{"reactions" => emoji_reactions}} <- object do
	Enum.map(emoji_reactions, fn [emoji, users] ->
	%{
	name: emoji,
	count: length(users),
	me: !!(opts[:for] && opts[:for].ap_id in users)
	}
	end)
	else
	_ -> []
	end

	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
	)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for],
	relationships: opts[:relationships]
	}),
	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,
	created_at: created_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?(bookmarked),
	muted: muted,
	pinned: pinned?(activity, user),
	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: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	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
	}
	}
	end

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

	def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
	page_url_data = URI.parse(page_url)

	page_url_data =
	if rich_media[:url] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:url]))
	else
	page_url_data
	end

	page_url = page_url_data \|> to_string

	image_url =
	if rich_media[:image] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:image]))
	\|> to_string
	else
	nil
	end

	%{
	type: "link",
	provider_name: page_url_data.host,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url \|> MediaProxy.url(),
	title: rich_media[:title] \|\| "",
	description: rich_media[:description] \|\| "",
	pleroma: %{
	opengraph: rich_media
	}
	}
	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()

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

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href,
	text_url: href,
	type: type,
	description: attachment["name"],
	pleroma: %{mime_type: media_type}
	}
	end

	def render("listen.json", %{activity: %Activity{data: %{"type" => "Listen"}} = activity} = opts) do
	object = Object.normalize(activity)

	user = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	%{
	id: activity.id,
	account: AccountView.render("show.json", %{user: user, for: opts[:for]}),
	created_at: created_at,
	title: object.data["title"] \|> HTML.strip_tags(),
	artist: object.data["artist"] \|> HTML.strip_tags(),
	album: object.data["album"] \|> HTML.strip_tags(),
	length: object.data["length"]
	}
	end

	def render("listens.json", opts) do
	safe_render_many(opts.activities, StatusView, "listen.json", opts)
	end

	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)

	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)

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

	def render_content(%{data: %{"type" => object_type}} = object)
	when object_type in ["Video", "Event", "Audio"] do
	with name when not is_nil(name) and name != "" <- object.data["name"] do
	"<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
	else
	_ -> object.data["content"] \|\| ""
	end
	end

	def render_content(%{data: %{"type" => object_type}} = object)
	when object_type in ["Article", "Page"] do
	with summary when not is_nil(summary) and summary != "" <- object.data["name"],
	url when is_bitstring(url) <- object.data["url"] do
	"<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
	else
	_ -> object.data["content"] \|\| ""
	end
	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 = for tag when is_binary(tag) <- object_tags, do: tag

	Enum.reduce(object_tags, [], fn tag, tags ->
	tags ++ [%{name: tag, url: "/tag/#{URI.encode(tag)}"}]
	end)
	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 pinned?(%Activity{id: id}, %User{pinned_activities: pinned_activities}),
	do: id in pinned_activities
	end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	index 30838b1eb..f9a5ddcc0 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	@@ -1,168 +1,169 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
	use Pleroma.Web, :controller

	alias Pleroma.Config
	alias Pleroma.Stats
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.Federator.Publisher

	def schemas(conn, _params) do
	response = %{
	links: [
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
	href: Web.base_url() <> "/nodeinfo/2.0.json"
	},
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
	href: Web.base_url() <> "/nodeinfo/2.1.json"
	}
	]
	}

	json(conn, response)
	end

	# returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
	# under software.
	def raw_nodeinfo do
	stats = Stats.get_stats()

	quarantined = Config.get([:instance, :quarantined_instances], [])

	staff_accounts =
	User.all_superusers()
	\|> Enum.map(fn u -> u.ap_id end)

	federation_response =
	if Config.get([:instance, :mrf_transparency]) do
	{:ok, data} = MRF.describe()

	data
	\|> Map.merge(%{quarantined_instances: quarantined})
	else
	%{}
	end
	\|> Map.put(:enabled, Config.get([:instance, :federating]))

	features =
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	"polls",
	"pleroma_explicit_addressing",
	"shareable_emoji_packs",
	"multifetch",
	"pleroma:api/v1/notifications:include_types_filter",
	if Config.get([:media_proxy, :enabled]) do
	"media_proxy"
	end,
	if Config.get([:gopher, :enabled]) do
	"gopher"
	end,
	if Config.get([:chat, :enabled]) do
	"chat"
	end,
	if Config.get([:instance, :allow_relay]) do
	"relay"
	end,
	if Config.get([:instance, :safe_dm_mentions]) do
	"safe_dm_mentions"
	- end
	+ end,
	+ "pleroma_emoji_reactions"
	]
	\|> Enum.filter(& &1)

	%{
	version: "2.0",
	software: %{
	name: Pleroma.Application.name() \|> String.downcase(),
	version: Pleroma.Application.version()
	},
	protocols: Publisher.gather_nodeinfo_protocol_names(),
	services: %{
	inbound: [],
	outbound: []
	},
	openRegistrations: Config.get([:instance, :registrations_open]),
	usage: %{
	users: %{
	total: Map.get(stats, :user_count, 0)
	},
	localPosts: Map.get(stats, :status_count, 0)
	},
	metadata: %{
	nodeName: Config.get([:instance, :name]),
	nodeDescription: Config.get([:instance, :description]),
	private: !Config.get([:instance, :public], true),
	suggestions: %{
	enabled: false
	},
	staffAccounts: staff_accounts,
	federation: federation_response,
	pollLimits: Config.get([:instance, :poll_limits]),
	postFormats: Config.get([:instance, :allowed_post_formats]),
	uploadLimits: %{
	general: Config.get([:instance, :upload_limit]),
	avatar: Config.get([:instance, :avatar_upload_limit]),
	banner: Config.get([:instance, :banner_upload_limit]),
	background: Config.get([:instance, :background_upload_limit])
	},
	fieldsLimits: %{
	maxFields: Config.get([:instance, :max_account_fields]),
	maxRemoteFields: Config.get([:instance, :max_remote_account_fields]),
	nameLength: Config.get([:instance, :account_field_name_length]),
	valueLength: Config.get([:instance, :account_field_value_length])
	},
	accountActivationRequired: Config.get([:instance, :account_activation_required], false),
	invitesEnabled: Config.get([:instance, :invites_enabled], false),
	mailerEnabled: Config.get([Pleroma.Emails.Mailer, :enabled], false),
	features: features,
	restrictedNicknames: Config.get([Pleroma.User, :restricted_nicknames]),
	skipThreadContainment: Config.get([:instance, :skip_thread_containment], false)
	}
	}
	end

	# Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
	# and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
	def nodeinfo(conn, %{"version" => "2.0"}) do
	conn
	\|> put_resp_header(
	"content-type",
	"application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	)
	\|> json(raw_nodeinfo())
	end

	def nodeinfo(conn, %{"version" => "2.1"}) do
	raw_response = raw_nodeinfo()

	updated_software =
	raw_response
	\|> Map.get(:software)
	\|> Map.put(:repository, Pleroma.Application.repository())

	response =
	raw_response
	\|> Map.put(:software, updated_software)
	\|> Map.put(:version, "2.1")

	conn
	\|> put_resp_header(
	"content-type",
	"application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
	)
	\|> json(response)
	end

	def nodeinfo(conn, _) do
	render_error(conn, :not_found, "Nodeinfo schema version not handled")
	end
	end
	diff --git a/test/fixtures/emoji/packs/blank.png.zip b/test/fixtures/emoji/packs/blank.png.zip
	new file mode 100644
	index 000000000..651daf127
	Binary files /dev/null and b/test/fixtures/emoji/packs/blank.png.zip differ
	diff --git a/test/fixtures/emoji/packs/default-manifest.json b/test/fixtures/emoji/packs/default-manifest.json
	new file mode 100644
	index 000000000..c8433808d
	--- /dev/null
	+++ b/test/fixtures/emoji/packs/default-manifest.json
	@@ -0,0 +1,10 @@
	+{
	+ "finmoji": {
	+ "license": "CC BY-NC-ND 4.0",
	+ "homepage": "https://finland.fi/emoji/",
	+ "description": "Finland is the first country in the world to publish its own set of country themed emojis. The Finland emoji collection contains 56 tongue-in-cheek emotions, which were created to explain some hard-to-describe Finnish emotions, Finnish words and customs.",
	+ "src": "https://finland.fi/wp-content/uploads/2017/06/finland-emojis.zip",
	+ "src_sha256": "384025A1AC6314473863A11AC7AB38A12C01B851A3F82359B89B4D4211D3291D",
	+ "files": "finmoji.json"
	+ }
	+}
	\ No newline at end of file
	diff --git a/test/fixtures/emoji/packs/finmoji.json b/test/fixtures/emoji/packs/finmoji.json
	new file mode 100644
	index 000000000..279770998
	--- /dev/null
	+++ b/test/fixtures/emoji/packs/finmoji.json
	@@ -0,0 +1,3 @@
	+{
	+ "blank": "blank.png"
	+}
	\ No newline at end of file
	diff --git a/test/fixtures/emoji/packs/manifest.json b/test/fixtures/emoji/packs/manifest.json
	new file mode 100644
	index 000000000..2d51a459b
	--- /dev/null
	+++ b/test/fixtures/emoji/packs/manifest.json
	@@ -0,0 +1,10 @@
	+{
	+ "blobs.gg": {
	+ "src_sha256": "3a12f3a181678d5b3584a62095411b0d60a335118135910d879920f8ade5a57f",
	+ "src": "https://git.pleroma.social/pleroma/emoji-index/raw/master/packs/blobs_gg.zip",
	+ "license": "Apache 2.0",
	+ "homepage": "https://blobs.gg",
	+ "files": "blobs_gg.json",
	+ "description": "Blob Emoji from blobs.gg repacked as apng"
	+ }
	+}
	\ No newline at end of file
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index c3d70c51f..f78a47af6 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,947 +1,947 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase

	import Pleroma.Factory
	import Mock

	alias Pleroma.Notification
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	describe "create_notifications" do
	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, _object} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

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

	assert notification.user_id == user.id
	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 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
	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
	end

	describe "CommonApi.post/2 notification-related functionality" do
	test_with_mock "creates but does NOT send notification to blocker user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	blocker = insert(:user)
	{:ok, _user_relationship} = User.block(blocker, user)

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

	blocker_id = blocker.id
	assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to notification-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	muter = insert(:user)
	{:ok, _user_relationships} = User.mute(muter, user)

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

	muter_id = muter.id
	assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to thread-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	thread_muter = insert(:user)

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

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

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

	[pre_mute_notification, post_mute_notification] =
	Repo.all(from(n in Notification, where: n.user_id == ^thread_muter.id, order_by: n.id))

	pre_mute_notification_id = pre_mute_notification.id
	post_mute_notification_id = post_mute_notification.id

	assert called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^pre_mute_notification_id} -> true
	_ -> false
	end)
	)
	)

	refute called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^post_mute_notification_id} -> true
	_ -> false
	end)
	)
	)
	end
	end

	describe "create_notification" do
	@tag needs_streamer: true
	test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
	user = insert(:user)
	task = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	task_user_notification = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	Streamer.add_socket("user", %{transport_pid: task.pid, assigns: %{user: user}})

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task_user_notification.pid, assigns: %{user: user}}
	)

	activity = insert(:note_activity)

	notify = Notification.create_notification(activity, user)
	assert notify.user_id == user.id
	Task.await(task)
	Task.await(task_user_notification)
	end

	test "it creates a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, _user_relationship} = User.block(user, author)

	assert Notification.create_notification(activity, user)
	end

	test "it creates a notification for the user if the user mutes the activity author" do
	muter = insert(:user)
	muted = insert(:user)
	{:ok, _} = User.mute(muter, muted)
	muter = Repo.get(User, muter.id)
	{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "notification created if user is muted without notifications" do
	muter = insert(:user)
	muted = insert(:user)

	{:ok, _user_relationships} = User.mute(muter, muted, false)

	{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "it creates a notification for an activity from a muted thread" do
	muter = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"})
	CommonAPI.add_mute(muter, activity)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	"status" => "Hi @#{muter.nickname}",
	"in_reply_to_status_id" => activity.id
	})

	assert Notification.create_notification(activity, muter)
	end

	test "it disables notifications from followers" do
	follower = insert(:user)

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

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

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

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

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

	test "it disables notifications from people the user follows" do
	follower =
	insert(:user, notification_settings: %Pleroma.User.NotificationSetting{follows: false})

	followed = insert(:user)
	User.follow(follower, followed)
	follower = Repo.get(User, follower.id)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute Notification.create_notification(activity, follower)
	end

	test "it disables notifications from people the user does not follow" do
	follower =
	insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})

	followed = insert(:user)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute Notification.create_notification(activity, follower)
	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 a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, followed_user)
	Notification.create_notification(activity, followed_user)
	CommonAPI.unfollow(user, followed_user)
	{:ok, _, _, activity_dupe} = CommonAPI.follow(user, followed_user)
	refute Notification.create_notification(activity_dupe, followed_user)
	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
	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] = notifs = Notification.for_user(other_user)
	assert length(notifs) == 2

	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, _disabled_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",
	"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, _disabled_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",
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

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

	{enabled_receivers, _disabled_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(activity_one.id, third_user)
	+ {:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id)

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	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, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it returns blocking recipient in disabled 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, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns notification-muting recipient in disabled 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, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns thread-muting recipient in disabled 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, disabled_receivers} =
	Notification.get_notified_from_activity(same_context_activity)

	assert [other_user] == disabled_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(activity.id, other_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(activity.id, other_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, _} = CommonAPI.favorite(activity.id, other_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 "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	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",
	"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

	@tag capture_log: true
	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)

	old_user_url = old_user.ap_id

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", old_user.nickname)
	\|> Jason.encode!()

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

	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
	test "it returns notifications for muted user without notifications" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, false)

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

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

	test "it doesn't return notifications for muted user with notifications" do
	user = insert(:user)
	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" do
	user = insert(:user)
	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 blocked domain" do
	user = insert(:user)
	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 doesn't return notifications for muted thread" do
	user = insert(:user)
	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 returns notifications from a muted user when with_muted is set" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

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

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications from a blocked user when with_muted is set" do
	user = insert(:user)
	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 "it doesn't return notifications from a domain-blocked user when with_muted is set" do
	user = insert(:user)
	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" do
	user = insert(:user)
	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
	end
	end
	diff --git a/test/object_test.exs b/test/object_test.exs
	index fe583decd..198d3b1cf 100644
	--- a/test/object_test.exs
	+++ b/test/object_test.exs
	@@ -1,401 +1,402 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ObjectTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo
	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.CommonAPI

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

	test "returns an object by it's AP id" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object
	end

	describe "generic changeset" do
	test "it ensures uniqueness of the id" do
	object = insert(:note)
	cs = Object.change(%Object{}, %{data: %{id: object.data["id"]}})
	assert cs.valid?

	{:error, _result} = Repo.insert(cs)
	end
	end

	describe "deletion function" do
	test "deletes an object" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object

	Object.delete(found_object)

	found_object = Object.get_by_ap_id(object.data["id"])

	refute object == found_object

	assert found_object.data["type"] == "Tombstone"
	end

	test "ensures cache is cleared for the object" do
	object = insert(:note)
	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	assert object == cached_object

	Cachex.put(:web_resp_cache, URI.parse(object.data["id"]).path, "cofe")

	Object.delete(cached_object)

	{:ok, nil} = Cachex.get(:object_cache, "object:#{object.data["id"]}")
	{:ok, nil} = Cachex.get(:web_resp_cache, URI.parse(object.data["id"]).path)

	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	refute object == cached_object

	assert cached_object.data["type"] == "Tombstone"
	end
	end

	describe "delete attachments" do
	setup do: clear_config([Pleroma.Upload])
	setup do: clear_config([:instance, :cleanup_attachments])

	test "Disabled via config" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([:instance, :cleanup_attachments], false)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	refute Object.get_by_id(attachment.id) == nil

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")
	end

	test "in subdirectories" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "with dedupe enabled" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([Pleroma.Upload, :filters], [Pleroma.Upload.Filter.Dedupe])
	Pleroma.Config.put([:instance, :cleanup_attachments], true)

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	File.mkdir_p!(uploads_dir)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	filename = Path.basename(href)

	assert {:ok, files} = File.ls(uploads_dir)
	assert filename in files

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil
	assert {:ok, files} = File.ls(uploads_dir)
	refute filename in files
	end

	test "with objects that have legacy data.url attribute" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %Object{}} = Object.create(%{url: "https://google.com", actor: user.ap_id})

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "With custom base_url" do
	Pleroma.Config.put([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	Pleroma.Config.put([Pleroma.Upload, :base_url], "https://sub.domain.tld/dir/")
	Pleroma.Config.put([:instance, :cleanup_attachments], true)

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

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end
	end

	describe "normalizer" do
	test "fetches unknown objects by default" do
	%Object{} =
	object = Object.normalize("http://mastodon.example.org/@admin/99541947525187367")

	assert object.data["url"] == "http://mastodon.example.org/@admin/99541947525187367"
	end

	test "fetches unknown objects when fetch_remote is explicitly true" do
	%Object{} =
	object = Object.normalize("http://mastodon.example.org/@admin/99541947525187367", true)

	assert object.data["url"] == "http://mastodon.example.org/@admin/99541947525187367"
	end

	test "does not fetch unknown objects when fetch_remote is false" do
	assert is_nil(
	Object.normalize("http://mastodon.example.org/@admin/99541947525187367", false)
	)
	end
	end

	describe "get_by_id_and_maybe_refetch" do
	setup do
	mock(fn
	%{method: :get, url: "https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/tesla_mock/poll_original.json")}

	env ->
	apply(HttpRequestMock, :request, [env])
	end)

	mock_modified = fn resp ->
	mock(fn
	%{method: :get, url: "https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"} ->
	resp

	env ->
	apply(HttpRequestMock, :request, [env])
	end)
	end

	on_exit(fn -> mock(fn env -> apply(HttpRequestMock, :request, [env]) end) end)

	[mock_modified: mock_modified]
	end

	test "refetches if the time since the last refetch is greater than the interval", %{
	mock_modified: mock_modified
	} do
	%Object{} =
	object = Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d")

	Object.set_cache(object)

	assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0

	mock_modified.(%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/poll_modified.json")
	})

	updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	assert updated_object == object_in_cache
	assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 8
	assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 3
	end

	test "returns the old object if refetch fails", %{mock_modified: mock_modified} do
	%Object{} =
	object = Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d")

	Object.set_cache(object)

	assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0

	assert capture_log(fn ->
	mock_modified.(%Tesla.Env{status: 404, body: ""})

	updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	assert updated_object == object_in_cache
	assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	end) =~
	"[error] Couldn't refresh https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"
	end

	test "does not refetch if the time since the last refetch is greater than the interval", %{
	mock_modified: mock_modified
	} do
	%Object{} =
	object = Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d")

	Object.set_cache(object)

	assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0

	mock_modified.(%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/poll_modified.json")
	})

	updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: 100)
	object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	assert updated_object == object_in_cache
	assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	end

	test "preserves internal fields on refetch", %{mock_modified: mock_modified} do
	%Object{} =
	object = Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d")

	Object.set_cache(object)

	assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0

	user = insert(:user)
	activity = Activity.get_create_by_object_ap_id(object.data["id"])
	- {:ok, _activity, object} = CommonAPI.favorite(activity.id, user)
	+ {:ok, activity} = CommonAPI.favorite(user, activity.id)
	+ object = Object.get_by_ap_id(activity.data["object"])

	assert object.data["like_count"] == 1

	mock_modified.(%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/tesla_mock/poll_modified.json")
	})

	updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	assert updated_object == object_in_cache
	assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 8
	assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 3

	assert updated_object.data["like_count"] == 1
	end
	end
	end
	diff --git a/test/stat_test.exs b/test/stat_test.exs
	index 33b77e7e7..bccc1c8d0 100644
	--- a/test/stat_test.exs
	+++ b/test/stat_test.exs
	@@ -1,70 +1,70 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.StateTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

	describe "status visibility count" do
	test "on new status" do
	user = insert(:user)
	other_user = insert(:user)

	CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})

	Enum.each(0..1, fn _ ->
	CommonAPI.post(user, %{
	"visibility" => "unlisted",
	"status" => "hey"
	})
	end)

	Enum.each(0..2, fn _ ->
	CommonAPI.post(user, %{
	"visibility" => "direct",
	"status" => "hey @#{other_user.nickname}"
	})
	end)

	Enum.each(0..3, fn _ ->
	CommonAPI.post(user, %{
	"visibility" => "private",
	"status" => "hey"
	})
	end)

	assert %{direct: 3, private: 4, public: 1, unlisted: 2} =
	Pleroma.Stats.get_status_visibility_count()
	end

	test "on status delete" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
	assert %{public: 1} = Pleroma.Stats.get_status_visibility_count()
	CommonAPI.delete(activity.id, user)
	assert %{public: 0} = Pleroma.Stats.get_status_visibility_count()
	end

	test "on status visibility update" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
	assert %{public: 1, private: 0} = Pleroma.Stats.get_status_visibility_count()
	{:ok, _} = CommonAPI.update_activity_scope(activity.id, %{"visibility" => "private"})
	assert %{public: 0, private: 1} = Pleroma.Stats.get_status_visibility_count()
	end

	test "doesn't count unrelated activities" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
	_ = CommonAPI.follow(user, other_user)
	- CommonAPI.favorite(activity.id, other_user)
	+ CommonAPI.favorite(other_user, activity.id)
	CommonAPI.repeat(activity.id, other_user)

	assert %{direct: 0, private: 0, public: 1, unlisted: 0} =
	Pleroma.Stats.get_status_visibility_count()
	end
	end
	end
	diff --git a/test/tasks/database_test.exs b/test/tasks/database_test.exs
	index ed1c31d9c..7b05993d3 100644
	--- a/test/tasks/database_test.exs
	+++ b/test/tasks/database_test.exs
	@@ -1,130 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.DatabaseTest do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase

	import Pleroma.Factory

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

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running remove_embedded_objects" do
	test "it replaces objects with references" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	new_data = Map.put(activity.data, "object", activity.object.data)

	{:ok, activity} =
	activity
	\|> Activity.change(%{data: new_data})
	\|> Repo.update()

	assert is_map(activity.data["object"])

	Mix.Tasks.Pleroma.Database.run(["remove_embedded_objects"])

	activity = Activity.get_by_id_with_object(activity.id)
	assert is_binary(activity.data["object"])
	end
	end

	describe "prune_objects" do
	test "it prunes old objects from the database" do
	insert(:note)
	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days]) + 1

	date =
	Timex.now()
	\|> Timex.shift(days: -deadline)
	\|> Timex.to_naive_datetime()
	\|> NaiveDateTime.truncate(:second)

	%{id: id} =
	:note
	\|> insert()
	\|> Ecto.Changeset.change(%{inserted_at: date})
	\|> Repo.update!()

	assert length(Repo.all(Object)) == 2

	Mix.Tasks.Pleroma.Database.run(["prune_objects"])

	assert length(Repo.all(Object)) == 1
	refute Object.get_by_id(id)
	end
	end

	describe "running update_users_following_followers_counts" do
	test "following and followers count are updated" do
	[user, user2] = insert_pair(:user)
	{:ok, %User{} = user} = User.follow(user, user2)

	following = User.following(user)

	assert length(following) == 2
	assert user.follower_count == 0

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{follower_count: 3})
	\|> Repo.update()

	assert user.follower_count == 3

	assert :ok == Mix.Tasks.Pleroma.Database.run(["update_users_following_followers_counts"])

	user = User.get_by_id(user.id)

	assert length(User.following(user)) == 2
	assert user.follower_count == 0
	end
	end

	describe "running fix_likes_collections" do
	test "it turns OrderedCollection likes into empty arrays" do
	[user, user2] = insert_pair(:user)

	{:ok, %{id: id, object: object}} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, %{object: object2}} = CommonAPI.post(user, %{"status" => "test test"})

	- CommonAPI.favorite(id, user2)
	+ CommonAPI.favorite(user2, id)

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	new_data = Map.put(object2.data, "likes", likes)

	object2
	\|> Ecto.Changeset.change(%{data: new_data})
	\|> Repo.update()

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert is_map(Object.get_by_id(object2.id).data["likes"])

	assert :ok == Mix.Tasks.Pleroma.Database.run(["fix_likes_collections"])

	assert length(Object.get_by_id(object.id).data["likes"]) == 1
	assert Enum.empty?(Object.get_by_id(object2.id).data["likes"])
	end
	end
	end
	diff --git a/test/tasks/emoji_test.exs b/test/tasks/emoji_test.exs
	new file mode 100644
	index 000000000..f5de3ef0e
	--- /dev/null
	+++ b/test/tasks/emoji_test.exs
	@@ -0,0 +1,226 @@
	+defmodule Mix.Tasks.Pleroma.EmojiTest do
	+ use ExUnit.Case, async: true
	+
	+ import ExUnit.CaptureIO
	+ import Tesla.Mock
	+
	+ alias Mix.Tasks.Pleroma.Emoji
	+
	+ describe "ls-packs" do
	+ test "with default manifest as url" do
	+ mock(fn
	+ %{
	+ method: :get,
	+ url: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/default-manifest.json")
	+ }
	+ end)
	+
	+ capture_io(fn -> Emoji.run(["ls-packs"]) end) =~
	+ "https://finland.fi/wp-content/uploads/2017/06/finland-emojis.zip"
	+ end
	+
	+ test "with passed manifest as file" do
	+ capture_io(fn ->
	+ Emoji.run(["ls-packs", "-m", "test/fixtures/emoji/packs/manifest.json"])
	+ end) =~ "https://git.pleroma.social/pleroma/emoji-index/raw/master/packs/blobs_gg.zip"
	+ end
	+ end
	+
	+ describe "get-packs" do
	+ test "download pack from default manifest" do
	+ mock(fn
	+ %{
	+ method: :get,
	+ url: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/default-manifest.json")
	+ }
	+
	+ %{
	+ method: :get,
	+ url: "https://finland.fi/wp-content/uploads/2017/06/finland-emojis.zip"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/blank.png.zip")
	+ }
	+
	+ %{
	+ method: :get,
	+ url: "https://git.pleroma.social/pleroma/emoji-index/raw/master/finmoji.json"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/finmoji.json")
	+ }
	+ end)
	+
	+ assert capture_io(fn -> Emoji.run(["get-packs", "finmoji"]) end) =~ "Writing pack.json for"
	+
	+ emoji_path =
	+ Path.join(
	+ Pleroma.Config.get!([:instance, :static_dir]),
	+ "emoji"
	+ )
	+
	+ assert File.exists?(Path.join([emoji_path, "finmoji", "pack.json"]))
	+ on_exit(fn -> File.rm_rf!("test/instance_static/emoji/finmoji") end)
	+ end
	+
	+ test "pack not found" do
	+ mock(fn
	+ %{
	+ method: :get,
	+ url: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/default-manifest.json")
	+ }
	+ end)
	+
	+ assert capture_io(fn -> Emoji.run(["get-packs", "not_found"]) end) =~
	+ "No pack named \"not_found\" found"
	+ end
	+
	+ test "raise on bad sha256" do
	+ mock(fn
	+ %{
	+ method: :get,
	+ url: "https://git.pleroma.social/pleroma/emoji-index/raw/master/packs/blobs_gg.zip"
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: File.read!("test/fixtures/emoji/packs/blank.png.zip")
	+ }
	+ end)
	+
	+ assert_raise RuntimeError, ~r/^Bad SHA256 for blobs.gg/, fn ->
	+ capture_io(fn ->
	+ Emoji.run(["get-packs", "blobs.gg", "-m", "test/fixtures/emoji/packs/manifest.json"])
	+ end)
	+ end
	+ end
	+ end
	+
	+ describe "gen-pack" do
	+ setup do
	+ url = "https://finland.fi/wp-content/uploads/2017/06/finland-emojis.zip"
	+
	+ mock(fn %{
	+ method: :get,
	+ url: ^url
	+ } ->
	+ %Tesla.Env{status: 200, body: File.read!("test/fixtures/emoji/packs/blank.png.zip")}
	+ end)
	+
	+ {:ok, url: url}
	+ end
	+
	+ test "with default extensions", %{url: url} do
	+ name = "pack1"
	+ pack_json = "#{name}.json"
	+ files_json = "#{name}_file.json"
	+ refute File.exists?(pack_json)
	+ refute File.exists?(files_json)
	+
	+ captured =
	+ capture_io(fn ->
	+ Emoji.run([
	+ "gen-pack",
	+ url,
	+ "--name",
	+ name,
	+ "--license",
	+ "license",
	+ "--homepage",
	+ "homepage",
	+ "--description",
	+ "description",
	+ "--files",
	+ files_json,
	+ "--extensions",
	+ ".png .gif"
	+ ])
	+ end)
	+
	+ assert captured =~ "#{pack_json} has been created with the pack1 pack"
	+ assert captured =~ "Using .png .gif extensions"
	+
	+ assert File.exists?(pack_json)
	+ assert File.exists?(files_json)
	+
	+ on_exit(fn ->
	+ File.rm!(pack_json)
	+ File.rm!(files_json)
	+ end)
	+ end
	+
	+ test "with custom extensions and update existing files", %{url: url} do
	+ name = "pack2"
	+ pack_json = "#{name}.json"
	+ files_json = "#{name}_file.json"
	+ refute File.exists?(pack_json)
	+ refute File.exists?(files_json)
	+
	+ captured =
	+ capture_io(fn ->
	+ Emoji.run([
	+ "gen-pack",
	+ url,
	+ "--name",
	+ name,
	+ "--license",
	+ "license",
	+ "--homepage",
	+ "homepage",
	+ "--description",
	+ "description",
	+ "--files",
	+ files_json,
	+ "--extensions",
	+ " .png .gif .jpeg "
	+ ])
	+ end)
	+
	+ assert captured =~ "#{pack_json} has been created with the pack2 pack"
	+ assert captured =~ "Using .png .gif .jpeg extensions"
	+
	+ assert File.exists?(pack_json)
	+ assert File.exists?(files_json)
	+
	+ captured =
	+ capture_io(fn ->
	+ Emoji.run([
	+ "gen-pack",
	+ url,
	+ "--name",
	+ name,
	+ "--license",
	+ "license",
	+ "--homepage",
	+ "homepage",
	+ "--description",
	+ "description",
	+ "--files",
	+ files_json,
	+ "--extensions",
	+ " .png .gif .jpeg "
	+ ])
	+ end)
	+
	+ assert captured =~ "#{pack_json} has been updated with the pack2 pack"
	+
	+ on_exit(fn ->
	+ File.rm!(pack_json)
	+ File.rm!(files_json)
	+ end)
	+ end
	+ end
	+end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 8055ebd08..0479f294d 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1827 +1,1827 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

	describe "service actors" do
	test "returns updated invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	insert(
	:user,
	%{
	nickname: "relay",
	invisible: false,
	local: true,
	ap_id: uri,
	follower_address: followers_uri
	}
	)

	actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
	assert actor.invisible
	end

	test "returns relay user" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	assert %User{
	nickname: "relay",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = User.get_or_create_service_actor_by_ap_id(uri, "relay")

	assert capture_log(fn ->
	refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
	end) =~ "Cannot create service actor:"
	end

	test "returns invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
	followers_uri = "#{uri}/followers"
	user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")

	assert %User{
	nickname: "internal.fetch-test",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = user

	user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
	assert user.id == user2.id
	end
	end

	describe "AP ID user relationships" do
	setup do
	{:ok, user: insert(:user)}
	end

	test "outgoing_relationships_ap_ids/1", %{user: user} do
	rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]

	ap_ids_by_rel =
	Enum.into(
	rel_types,
	%{},
	fn rel_type ->
	rel_records =
	insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})

	ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
	{rel_type, Enum.sort(ap_ids)}
	end
	)

	assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
	assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
	assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(User.notification_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:reblog_mute] ==
	Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))

	assert ap_ids_by_rel[:inverse_subscription] ==
	Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))

	outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)

	assert ap_ids_by_rel ==
	Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
	end
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "ap_following returns the following collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/following"

	assert expected_followers_collection == User.ap_following(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, locked: true)
	follower = insert(:user)

	CommonAPI.follow(follower, unlocked)
	CommonAPI.follow(follower, locked)

	assert [] = User.get_follow_requests(unlocked)
	assert [activity] = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, locked: true)
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	CommonAPI.follow(pending_follower, locked)
	CommonAPI.follow(pending_follower, locked)
	CommonAPI.follow(accepted_follower, locked)
	Pleroma.FollowingRelationship.update(accepted_follower, locked, "accept")

	assert [^pending_follower] = User.get_follow_requests(locked)
	end

	test "clears follow requests when requester is blocked" do
	followed = insert(:user, locked: true)
	follower = insert(:user)

	CommonAPI.follow(follower, followed)
	assert [_activity] = User.get_follow_requests(followed)

	{:ok, _user_relationship} = User.block(followed, follower)
	assert [] = User.get_follow_requests(followed)
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

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

	{:ok, user} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(User.following(user)) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(User.following(user)) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)
	followed = User.get_cached_by_ap_id(followed.ap_id)

	assert followed.follower_count == 1
	assert user.following_count == 1

	assert User.ap_followers(followed) in User.following(user)
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, locked: true)
	followed = insert(:user, locked: true)

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	describe "unfollow/2" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "unfollow with syncronizes external user" do
	Pleroma.Config.put([:instance, :external_user_synchronization], true)

	followed =
	insert(:user,
	nickname: "fuser1",
	follower_address: "http://localhost:4001/users/fuser1/followers",
	following_address: "http://localhost:4001/users/fuser1/following",
	ap_id: "http://localhost:4001/users/fuser1"
	)

	user =
	insert(:user, %{
	local: false,
	nickname: "fuser2",
	ap_id: "http://localhost:4001/users/fuser2",
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	})

	{:ok, user} = User.follow(user, followed, "accept")

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert User.following(user) == []
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user)

	{:ok, user} = User.follow(user, followed, "accept")

	assert User.following(user) == [user.follower_address, followed.follower_address]

	{:ok, user, _activity} = User.unfollow(user, followed)

	assert User.following(user) == [user.follower_address]
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	assert User.following(user) == [user.follower_address]
	end
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user)
	User.follow(user, followed, "accept")

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}
	setup do: clear_config([:instance, :autofollowed_nicknames])
	setup do: clear_config([:instance, :welcome_message])
	setup do: clear_config([:instance, :welcome_user_nickname])

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)

	Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
	Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity).data["content"] =~ "cool site"
	assert activity.actor == welcome_user.ap_id
	end

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

	test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
	Pleroma.Config.put([:instance, :account_activation_required], false)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

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

	refute changeset.valid?
	end

	test "it sets the password_hash and ap_id" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}
	setup do: clear_config([:instance, :account_activation_required], true)

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.confirmation_pending
	assert user.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.confirmation_pending
	refute user.confirmation_token
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id
	)

	{:ok, fetched_user} = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	{:ok, fetched_user} =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	{:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "returns nil if no user could be fetched" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == "not found nonexistant@social.heldscal.la"
	end

	test "returns nil for nonexistant local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == "not found nonexistant"
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	assert user.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	avatar: %{some: "avatar"}
	}
	setup do: clear_config([:instance, :user_bio_length])
	setup do: clear_config([:instance, :user_name_length])

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert Ecto.Changeset.get_field(cs, :local) == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	res = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	res = User.get_friends(user)

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the note_count property" do
	note = insert(:note)

	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.note_count == 1
	end

	test "it increases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 2
	end

	test "it decreases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0
	end

	test "it sets the follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.follower_count == 1
	end
	end

	describe "follow_import" do
	test "it imports user followings from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	{:ok, job} = User.follow_import(user1, identifiers)
	result = ObanHelpers.perform(job)

	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

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

	assert User.mutes?(user, muted_user)
	assert User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it mutes user without notifications" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

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

	assert User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

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

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked_user)
	{:ok, _user_block} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _subscription} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end if wildcard added" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "blocks domain with wildcard for subdomain" do
	user = insert(:user)

	user_from_subdomain =
	insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})

	user_with_two_subdomains =
	insert(:user, %{
	ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
	})

	user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	assert User.blocks?(user, user_from_subdomain)
	assert User.blocks?(user, user_with_two_subdomains)
	assert User.blocks?(user, user_domain)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "follows take precedence over domain blocks" do
	user = insert(:user)
	good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})

	{:ok, user} = User.block_domain(user, "meanies.social")
	{:ok, user} = User.follow(user, good_eggo)

	refute User.blocks?(user, good_eggo)
	end
	end

	describe "blocks_import" do
	test "it imports user blocks from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	{:ok, job} = User.blocks_import(user1, identifiers)
	result = ObanHelpers.perform(job)

	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "get_recipients_from_activity" do
	test "get recipients" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test "has following" do
	actor = insert(:user)
	user = insert(:user)
	user_two = insert(:user)
	addressed = insert(:user, local: true)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, _actor} = User.follow(actor, user)
	{:ok, _actor} = User.follow(actor, user_two)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert addressed in recipients
	end
	end

	describe ".deactivate" do
	test "can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.deactivated
	end

	test "hide a user from followers" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user} = User.follow(user, user2)
	{:ok, _user} = User.deactivate(user)

	user2 = User.get_cached_by_id(user2.id)

	assert user2.follower_count == 0
	assert [] = User.get_followers(user2)
	end

	test "hide a user from friends" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2} = User.follow(user2, user)
	assert user2.following_count == 1
	assert User.following_count(user2) == 1

	{:ok, _user} = User.deactivate(user)

	user2 = User.get_cached_by_id(user2.id)

	assert refresh_record(user2).following_count == 0
	assert user2.following_count == 0
	assert User.following_count(user2) == 0
	assert [] = User.get_friends(user2)
	end

	test "hide a user's statuses from timelines and notifications" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2} = User.follow(user2, user)

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

	activity = Repo.preload(activity, :bookmark)

	[notification] = Pleroma.Notification.for_user(user2)
	assert notification.activity.id == activity.id

	assert [activity] == ActivityPub.fetch_public_activities(%{}) \|> Repo.preload(:bookmark)

	assert [%{activity \| thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	"user" => user2
	})

	{:ok, _user} = User.deactivate(user)

	assert [] == ActivityPub.fetch_public_activities(%{})
	assert [] == Pleroma.Notification.for_user(user2)

	assert [] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	"user" => user2
	})
	end
	end

	describe "delete" do
	setup do
	{:ok, user} = insert(:user) \|> User.set_cache()

	[user: user]
	end

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

	test ".delete_user_activities deletes all create activities", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})

	User.delete_user_activities(user)

	# TODO: Remove favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test "it deletes deactivated user" do
	{:ok, user} = insert(:user, deactivated: true) \|> User.set_cache()

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

	refute User.get_by_id(user.id)
	end

	test "it deletes a user, all follow relationships and all activities", %{user: user} do
	follower = insert(:user)
	{:ok, follower} = User.follow(follower, user)

	object = insert(:note, user: user)
	activity = insert(:note_activity, user: user, note: object)

	object_two = insert(:note, user: follower)
	activity_two = insert(:note_activity, user: follower, note: object_two)

	- {:ok, like, _} = CommonAPI.favorite(activity_two.id, user)
	- {:ok, like_two, _} = CommonAPI.favorite(activity.id, follower)
	+ {:ok, like} = CommonAPI.favorite(user, activity_two.id)
	+ {:ok, like_two} = CommonAPI.favorite(follower, activity.id)
	{:ok, repeat, _} = CommonAPI.repeat(activity_two.id, user)

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

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	refute User.get_by_id(user.id)
	assert {:ok, nil} == Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	user_activities =
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.all()
	\|> Enum.map(fn act -> act.data["type"] end)

	assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)

	refute Activity.get_by_id(activity.id)
	refute Activity.get_by_id(like.id)
	refute Activity.get_by_id(like_two.id)
	refute Activity.get_by_id(repeat.id)
	end

	test_with_mock "it sends out User Delete activity",
	%{user: user},
	Pleroma.Web.ActivityPub.Publisher,
	[:passthrough],
	[] do
	Pleroma.Config.put([:instance, :federating], true)

	{:ok, follower} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	{:ok, _} = User.follow(follower, user)

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

	assert ObanHelpers.member?(
	%{
	"op" => "publish_one",
	"params" => %{
	"inbox" => "http://mastodon.example.org/inbox",
	"id" => "pleroma:fakeid"
	}
	},
	all_enqueued(worker: Pleroma.Workers.PublisherWorker)
	)
	end
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	describe "insert or update a user from given data" do
	test "with normal data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	test "with overly long fields" do
	current_max_length = Pleroma.Config.get([:instance, :account_field_value_length], 255)
	user = insert(:user, nickname: "nickname@supergood.domain")

	data = %{
	ap_id: user.ap_id,
	name: user.name,
	nickname: user.nickname,
	fields: [
	%{"name" => "myfield", "value" => String.duplicate("h", current_max_length + 1)}
	]
	}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	test "with an overly long bio" do
	current_max_length = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	user = insert(:user, nickname: "nickname@supergood.domain")

	data = %{
	ap_id: user.ap_id,
	name: user.name,
	nickname: user.nickname,
	bio: String.duplicate("h", current_max_length + 1)
	}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	test "with an overly long display name" do
	current_max_length = Pleroma.Config.get([:instance, :user_name_length], 100)
	user = insert(:user, nickname: "nickname@supergood.domain")

	data = %{
	ap_id: user.ap_id,
	name: String.duplicate("h", current_max_length + 1),
	nickname: user.nickname
	}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, no_rich_text: true)

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)

	User.set_cache(user)
	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

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

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "account_status/1" do
	setup do: clear_config([:instance, :account_activation_required])

	test "return confirmation_pending for unconfirm user" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	user = insert(:user, confirmation_pending: true)
	assert User.account_status(user) == :confirmation_pending
	end

	test "return active for confirmed user" do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	user = insert(:user, confirmation_pending: false)
	assert User.account_status(user) == :active
	end

	test "return active for remote user" do
	user = insert(:user, local: false)
	assert User.account_status(user) == :active
	end

	test "returns :password_reset_pending for user with reset password" do
	user = insert(:user, password_reset_pending: true)
	assert User.account_status(user) == :password_reset_pending
	end

	test "returns :deactivated for deactivated user" do
	user = insert(:user, local: true, confirmation_pending: false, deactivated: true)
	assert User.account_status(user) == :deactivated
	end
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, is_admin: true)

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, is_moderator: true)

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, is_admin: true)

	assert User.superuser?(user)
	end
	end

	describe "invisible?/1" do
	test "returns true for an invisible user" do
	user = insert(:user, local: true, invisible: true)

	assert User.invisible?(user)
	end

	test "returns false for a non-invisible user" do
	user = insert(:user, local: true)

	refute User.invisible?(user)
	end
	end

	describe "visible_for?/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for?(user, user)
	end

	test "returns false when the account is unauthenticated and auth is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, confirmation_pending: true)
	other_user = insert(:user, local: true)

	refute User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and auth is not required" do
	user = insert(:user, local: true, confirmation_pending: true)
	other_user = insert(:user, local: true)

	assert User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, confirmation_pending: true)
	other_user = insert(:user, local: true, is_admin: true)

	assert User.visible_for?(user, other_user)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	~s(A.k.a. <span class="h-card"><a data-user="#{remote_user.id}" class="u-url mention" href="#{
	remote_user.ap_id
	}" rel="ugc">@<span>nick@domain.com</span></a></span>)

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	bio = "http://example.com/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/link"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	{:ok, _follower2} = User.follow(follower2, user)
	{:ok, _follower3} = User.follow(follower3, user)

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

	assert user.follower_count == 2
	end

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

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	CommonAPI.post(user, %{
	"status" => "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), deactivated: false)
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	CommonAPI.post(sender, %{
	"status" => "hey @#{to.nickname}"
	})

	{:ok, _} =
	CommonAPI.post(sender, %{
	"status" => "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "toggle_confirmation/1" do
	test "if user is confirmed" do
	user = insert(:user, confirmation_pending: false)
	{:ok, user} = User.toggle_confirmation(user)

	assert user.confirmation_pending
	assert user.confirmation_token
	end

	test "if user is unconfirmed" do
	user = insert(:user, confirmation_pending: true, confirmation_token: "some token")
	{:ok, user} = User.toggle_confirmation(user)

	refute user.confirmation_pending
	refute user.confirmation_token
	end
	end

	describe "ensure_keys_present" do
	test "it creates keys for a user and stores them in info" do
	user = insert(:user)
	refute is_binary(user.keys)
	{:ok, user} = User.ensure_keys_present(user)
	assert is_binary(user.keys)
	end

	test "it doesn't create keys if there already are some" do
	user = insert(:user, keys: "xxx")
	{:ok, user} = User.ensure_keys_present(user)
	assert user.keys == "xxx"
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, deactivated: true)
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "is_internal_user?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.is_internal_user?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.is_internal_user?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.is_internal_user?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "updates the counters normally on following/getting a follow when disabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	{:ok, user} = Pleroma.User.follow(user, other_user)
	other_user = Pleroma.User.get_by_id(other_user.id)

	assert user.following_count == 1
	assert other_user.follower_count == 1
	end

	test "syncronizes the counters with the remote instance for the followed when enabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	Pleroma.Config.put([:instance, :external_user_synchronization], true)
	{:ok, _user} = User.follow(user, other_user)
	other_user = User.get_by_id(other_user.id)

	assert other_user.follower_count == 437
	end

	test "syncronizes the counters with the remote instance for the follower when enabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	Pleroma.Config.put([:instance, :external_user_synchronization], true)
	{:ok, other_user} = User.follow(other_user, user)

	assert other_user.following_count == 152
	end
	end

	describe "change_email/2" do
	setup do
	[user: insert(:user)]
	end

	test "blank email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
	end

	test "non unique email returns error", %{user: user} do
	%{email: email} = insert(:user)

	assert {:error, %{errors: [email: {"has already been taken", _}]}} =
	User.change_email(user, email)
	end

	test "invalid email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"has invalid format", _}]}} =
	User.change_email(user, "cofe")
	end

	test "changes email", %{user: user} do
	assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
	end
	end

	describe "get_cached_by_nickname_or_id" do
	setup do
	local_user = insert(:user)
	remote_user = insert(:user, nickname: "nickname@example.com", local: false)

	[local_user: local_user, remote_user: remote_user]
	end

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

	test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
	remote_user: remote_user
	} do
	Pleroma.Config.put([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	Pleroma.Config.put([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
	end

	test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user} do
	Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user, local_user: local_user} do
	Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
	end

	test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
	%{remote_user: remote_user} do
	Pleroma.Config.put([:instance, :limit_to_local_content], true)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
	%{local_user: local_user} do
	Pleroma.Config.put([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	Pleroma.Config.put([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
	end
	end

	describe "update_email_notifications/2" do
	setup do
	user = insert(:user, email_notifications: %{"digest" => true})

	{:ok, user: user}
	end

	test "Notifications are updated", %{user: user} do
	true = user.email_notifications["digest"]
	assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
	assert result.email_notifications["digest"] == false
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 049b14498..17e7b97de 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,1977 +1,1977 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Federator

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

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

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

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	"status" => "@#{user_two.nickname}",
	"visibility" => "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})

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

	{:ok, unlisted_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})

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

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})

	assert activities == [private_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	:visibility => ~w[private public],
	"actor_id" => user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})

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

	{:ok, unlisted_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})

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

	activities =
	ActivityPub.fetch_activities([], %{
	"exclude_visibilities" => "direct",
	"actor_id" => user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	"exclude_visibilities" => "unlisted",
	"actor_id" => user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	"exclude_visibilities" => "private",
	"actor_id" => user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	"exclude_visibilities" => "public",
	"actor_id" => user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.source_data
	assert user.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
	{:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})

	fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})

	fetch_two =
	ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	"type" => "Create",
	"tag" => ["test", "essais"],
	"tag_reject" => ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	"type" => "Create",
	"tag" => ["test"],
	"tag_all" => ["test", "reject"]
	})

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	assert activity.data["context_id"]
	assert object.data["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{"type" => ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	test "it reverts create" do
	user = insert(:user)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

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

	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities" do
	user = insert(:user)

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "1",
	"visibility" => "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "3",
	"visibility" => "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	ap_id = activity.data["id"]
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	refute activity in activities

	followed_user = insert(:user)
	ActivityPub.follow(user, followed_user)
	{:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	refute repeat_activity in activities
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity, _} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})

	refute repeat_activity in activities
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	"muting_user" => user,
	"with_muted" => true,
	"skip_preload" => true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{"muting_user" => user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "with_muted" => true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user} = User.follow(user, booster)

	{:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})

	assert activity == expected_activity
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} =
	CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities =
	ActivityPub.fetch_public_activities(%{"page" => "2", "page_size" => "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)

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

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)

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

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "react to an object" do
	test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
	Config.put([:instance, :federating], true)
	user = insert(:user)
	reactor = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
	assert object = Object.normalize(activity)

	{:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")

	assert called(Federator.publish(reaction_activity))
	end

	test "adds an emoji reaction activity to the db" do
	user = insert(:user)
	reactor = insert(:user)
	third_user = insert(:user)
	fourth_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
	assert object = Object.normalize(activity)

	{:ok, reaction_activity, object} = ActivityPub.react_with_emoji(reactor, object, "🔥")

	assert reaction_activity

	assert reaction_activity.data["actor"] == reactor.ap_id
	assert reaction_activity.data["type"] == "EmojiReact"
	assert reaction_activity.data["content"] == "🔥"
	assert reaction_activity.data["object"] == object.data["id"]
	assert reaction_activity.data["to"] == [User.ap_followers(reactor), activity.data["actor"]]
	assert reaction_activity.data["context"] == object.data["context"]
	assert object.data["reaction_count"] == 1
	assert object.data["reactions"] == [["🔥", [reactor.ap_id]]]

	{:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(third_user, object, "☕")

	assert object.data["reaction_count"] == 2
	assert object.data["reactions"] == [["🔥", [reactor.ap_id]], ["☕", [third_user.ap_id]]]

	{:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(fourth_user, object, "🔥")

	assert object.data["reaction_count"] == 3

	assert object.data["reactions"] == [
	["🔥", [fourth_user.ap_id, reactor.ap_id]],
	["☕", [third_user.ap_id]]
	]
	end

	test "reverts emoji reaction on error" do
	[user, reactor] = insert_list(2, :user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
	object = Object.normalize(activity)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.react_with_emoji(reactor, object, "😀")
	end

	object = Object.get_by_ap_id(object.data["id"])
	refute object.data["reaction_count"]
	refute object.data["reactions"]
	end
	end

	describe "unreacting to an object" do
	test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
	Config.put([:instance, :federating], true)
	user = insert(:user)
	reactor = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
	assert object = Object.normalize(activity)

	{:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")

	assert called(Federator.publish(reaction_activity))

	{:ok, unreaction_activity, _object} =
	ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])

	assert called(Federator.publish(unreaction_activity))
	end

	test "adds an undo activity to the db" do
	user = insert(:user)
	reactor = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
	assert object = Object.normalize(activity)

	{:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")

	{:ok, unreaction_activity, _object} =
	ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])

	assert unreaction_activity.actor == reactor.ap_id
	assert unreaction_activity.data["object"] == reaction_activity.data["id"]

	object = Object.get_by_ap_id(object.data["id"])
	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "reverts emoji unreact on error" do
	[user, reactor] = insert_list(2, :user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
	object = Object.normalize(activity)

	{:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "😀")

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
	end

	object = Object.get_by_ap_id(object.data["id"])

	assert object.data["reaction_count"] == 1
	assert object.data["reactions"] == [["😀", [reactor.ap_id]]]
	end
	end

	describe "like an object" do
	test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
	Config.put([:instance, :federating], true)
	note_activity = insert(:note_activity)
	assert object_activity = Object.normalize(note_activity)

	user = insert(:user)

	{:ok, like_activity, _object} = ActivityPub.like(user, object_activity)
	assert called(Federator.publish(like_activity))
	end

	test "returns exist activity if object already liked" do
	note_activity = insert(:note_activity)
	assert object_activity = Object.normalize(note_activity)

	user = insert(:user)

	{:ok, like_activity, _object} = ActivityPub.like(user, object_activity)

	{:ok, like_activity_exist, _object} = ActivityPub.like(user, object_activity)
	assert like_activity == like_activity_exist
	end

	test "reverts like activity on error" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.like(user, object)
	end

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.get(Object, object.id) == object
	end

	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity)

	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]
	assert object.data["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
	Config.put([:instance, :federating], true)

	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	{:ok, object} = ActivityPub.unlike(user, object)
	refute called(Federator.publish())

	{:ok, _like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert called(Federator.publish(unlike_activity))
	end

	test "reverts unliking on error" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unlike(user, object)
	end

	assert Object.get_by_ap_id(object.data["id"]) == object
	assert object.data["like_count"] == 1
	assert Activity.get_by_id(like_activity.id)
	end

	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert Activity.get_by_id(like_activity.id) == nil
	assert note_activity.actor in unlike_activity.recipients
	end
	end

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end

	test "reverts annouce from object on error" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.announce(user, object)
	end

	reloaded_object = Object.get_by_ap_id(object.data["id"])
	assert reloaded_object == object
	refute reloaded_object.data["announcement_count"]
	refute reloaded_object.data["announcements"]
	end
	end

	describe "announcing a private object" do
	test "adds an announce activity to the db if the audience is not widened" do
	user = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
	object = Object.normalize(note_activity)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)

	assert announce_activity.data["to"] == [User.ap_followers(user)]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end

	test "does not add an announce activity to the db if the audience is widened" do
	user = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
	object = Object.normalize(note_activity)

	assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
	end

	test "does not add an announce activity to the db if the announcer is not the author" do
	user = insert(:user)
	announcer = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
	object = Object.normalize(note_activity)

	assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	{:ok, object} = ActivityPub.unannounce(user, object)
	refute object.data["announcement_count"]

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	object.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

	assert Activity.get_by_id(announce_activity.id) == nil
	end

	test "reverts unannouncing on error" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

	{:ok, _announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unannounce(user, object)
	end

	object = Object.get_by_ap_id(object.data["id"])
	assert object.data["announcement_count"] == 1
	end
	end

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "following / unfollowing" do
	test "it reverts follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.follow(follower, followed)
	end

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

	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{locked: true})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "blocking / unblocking" do
	test "reverts block activity on error" do
	[blocker, blocked] = insert_list(2, :user)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.block(blocker, blocked)
	end

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

	test "creates a block activity" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity.data["type"] == "Block"
	assert activity.data["actor"] == blocker.ap_id
	assert activity.data["object"] == blocked.ap_id
	end

	test "reverts unblock activity on error" do
	[blocker, blocked] = insert_list(2, :user)
	{:ok, block_activity} = ActivityPub.block(blocker, blocked)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unblock(blocker, blocked)
	end

	assert block_activity.data["type"] == "Block"
	assert block_activity.data["actor"] == blocker.ap_id

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

	test "creates an undo activity for the last block" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, block_activity} = ActivityPub.block(blocker, blocked)
	{:ok, activity} = ActivityPub.unblock(blocker, blocked)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == blocker.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Block"
	assert embedded_object["object"] == blocked.ap_id
	assert embedded_object["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	setup do: clear_config([:instance, :rewrite_policy])

	test "it reverts deletion on error" do
	note = insert(:note_activity)
	object = Object.normalize(note)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.delete(object)
	end

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.get(Object, object.id) == object
	assert Activity.get_by_id(note.id) == note
	end

	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.normalize(note)
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == object.data["id"]

	assert Activity.get_by_id(delete.id) != nil

	assert Repo.get(Object, object.id).data["type"] == "Tombstone"
	end

	test "it doesn't fail when an activity was already deleted" do
	{:ok, delete} = insert(:note_activity) \|> Object.normalize() \|> ActivityPub.delete()

	assert {:ok, ^delete} = delete \|> Object.normalize() \|> ActivityPub.delete()
	end

	test "decrements user note count only for public activities" do
	user = insert(:user, note_count: 10)

	{:ok, a1} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "public"
	})

	{:ok, a2} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "unlisted"
	})

	{:ok, a3} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "private"
	})

	{:ok, a4} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "direct"
	})

	{:ok, _} = Object.normalize(a1) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a2) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a3) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a4) \|> ActivityPub.delete()

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 10
	end

	test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
	user = insert(:user)
	note = insert(:note_activity)
	object = Object.normalize(note)

	{:ok, object} =
	object
	\|> Object.change(%{
	data: %{
	"actor" => object.data["actor"],
	"id" => object.data["id"],
	"to" => [user.ap_id],
	"type" => "Note"
	}
	})
	\|> Object.update_and_set_cache()

	{:ok, delete} = ActivityPub.delete(object)

	assert user.ap_id in delete.data["to"]
	end

	test "decreases reply count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
	ap_id = activity.data["id"]

	{:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	{:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	{:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	{:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))

	_ = CommonAPI.delete(direct_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(private_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(public_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	_ = CommonAPI.delete(unlisted_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 0
	end

	test "it passes delete activity through MRF before deleting the object" do
	Pleroma.Config.put([:instance, :rewrite_policy], Pleroma.Web.ActivityPub.MRF.DropPolicy)

	note = insert(:note_activity)
	object = Object.normalize(note)

	{:error, {:reject, _}} = ActivityPub.delete(object)

	assert Activity.get_by_id(note.id)
	assert Repo.get(Object, object.id).data["type"] == object.data["type"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})

	{:ok, private_activity_1} =
	CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	"status" => "hi 3",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	"status" => "hi 4",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{"user" => user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "update" do
	setup do: clear_config([:instance, :max_pinned_statuses])

	test "it creates an update activity with the new user data" do
	user = insert(:user)
	{:ok, user} = User.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert embedded_object = update.data["object"]
	assert embedded_object["id"] == user_data["id"]
	assert embedded_object["type"] == user_data["type"]
	end
	end

	test "returned pinned statuses" do
	Config.put([:instance, :max_pinned_statuses], 3)
	user = insert(:user)

	{:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})

	CommonAPI.pin(activity_one.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_two.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_three.id, user)
	user = refresh_record(user)

	activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})

	assert 3 = length(activities)
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" => AccountView.render("show.json", %{user: target_account})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data =
	put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "thought I looked cute might delete later :3",
	"visibility" => "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	"status" => "why is tenshi eating a corndog so cute?",
	"visibility" => "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "syncronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	})

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	})

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})

	- {:ok, _, _} = CommonAPI.favorite(a4.id, user)
	- {:ok, _, _} = CommonAPI.favorite(a3.id, other_user)
	- {:ok, _, _} = CommonAPI.favorite(a3.id, user)
	- {:ok, _, _} = CommonAPI.favorite(a5.id, other_user)
	- {:ok, _, _} = CommonAPI.favorite(a5.id, user)
	- {:ok, _, _} = CommonAPI.favorite(a4.id, other_user)
	- {:ok, _, _} = CommonAPI.favorite(a1.id, user)
	- {:ok, _, _} = CommonAPI.favorite(a1.id, other_user)
	+ {:ok, _} = CommonAPI.favorite(user, a4.id)
	+ {:ok, _} = CommonAPI.favorite(other_user, a3.id)
	+ {:ok, _} = CommonAPI.favorite(user, a3.id)
	+ {:ok, _} = CommonAPI.favorite(other_user, a5.id)
	+ {:ok, _} = CommonAPI.favorite(user, a5.id)
	+ {:ok, _} = CommonAPI.favorite(other_user, a4.id)
	+ {:ok, _} = CommonAPI.favorite(user, a1.id)
	+ {:ok, _} = CommonAPI.favorite(other_user, a1.id)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{"limit" => 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" 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)
	follower_move_opted_out = insert(:user, allow_following_move: false)

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

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(params, nil)

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end
	end
	end
	diff --git a/test/web/activity_pub/object_validator_test.exs b/test/web/activity_pub/object_validator_test.exs
	new file mode 100644
	index 000000000..3c5c3696e
	--- /dev/null
	+++ b/test/web/activity_pub/object_validator_test.exs
	@@ -0,0 +1,83 @@
	+defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	+ alias Pleroma.Web.ActivityPub.Utils
	+ alias Pleroma.Web.CommonAPI
	+
	+ import Pleroma.Factory
	+
	+ describe "likes" do
	+ setup do
	+ user = insert(:user)
	+ {:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})
	+
	+ valid_like = %{
	+ "to" => [user.ap_id],
	+ "cc" => [],
	+ "type" => "Like",
	+ "id" => Utils.generate_activity_id(),
	+ "object" => post_activity.data["object"],
	+ "actor" => user.ap_id,
	+ "context" => "a context"
	+ }
	+
	+ %{valid_like: valid_like, user: user, post_activity: post_activity}
	+ end
	+
	+ test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
	+ {:ok, object, _meta} = ObjectValidator.validate(valid_like, [])
	+
	+ assert "id" in Map.keys(object)
	+ end
	+
	+ test "is valid for a valid object", %{valid_like: valid_like} do
	+ assert LikeValidator.cast_and_validate(valid_like).valid?
	+ end
	+
	+ test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
	+ without_actor = Map.delete(valid_like, "actor")
	+
	+ refute LikeValidator.cast_and_validate(without_actor).valid?
	+
	+ with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")
	+
	+ refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
	+ end
	+
	+ test "it errors when the object is missing or not known", %{valid_like: valid_like} do
	+ without_object = Map.delete(valid_like, "object")
	+
	+ refute LikeValidator.cast_and_validate(without_object).valid?
	+
	+ with_invalid_object = Map.put(valid_like, "object", "invalidobject")
	+
	+ refute LikeValidator.cast_and_validate(with_invalid_object).valid?
	+ end
	+
	+ test "it errors when the actor has already like the object", %{
	+ valid_like: valid_like,
	+ user: user,
	+ post_activity: post_activity
	+ } do
	+ _like = CommonAPI.favorite(user, post_activity.id)
	+
	+ refute LikeValidator.cast_and_validate(valid_like).valid?
	+ end
	+
	+ test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
	+ wrapped_like =
	+ valid_like
	+ \|> Map.put("actor", %{"id" => valid_like["actor"]})
	+ \|> Map.put("object", %{"id" => valid_like["object"]})
	+
	+ validated = LikeValidator.cast_and_validate(wrapped_like)
	+
	+ assert validated.valid?
	+
	+ assert {:actor, valid_like["actor"]} in validated.changes
	+ assert {:object, valid_like["object"]} in validated.changes
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/object_validators/note_validator_test.exs b/test/web/activity_pub/object_validators/note_validator_test.exs
	new file mode 100644
	index 000000000..30c481ffb
	--- /dev/null
	+++ b/test/web/activity_pub/object_validators/note_validator_test.exs
	@@ -0,0 +1,35 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.NoteValidatorTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.NoteValidator
	+ alias Pleroma.Web.ActivityPub.Utils
	+
	+ import Pleroma.Factory
	+
	+ describe "Notes" do
	+ setup do
	+ user = insert(:user)
	+
	+ note = %{
	+ "id" => Utils.generate_activity_id(),
	+ "type" => "Note",
	+ "actor" => user.ap_id,
	+ "to" => [user.follower_address],
	+ "cc" => [],
	+ "content" => "Hellow this is content.",
	+ "context" => "xxx",
	+ "summary" => "a post"
	+ }
	+
	+ %{user: user, note: note}
	+ end
	+
	+ test "a basic note validates", %{note: note} do
	+ %{valid?: true} = NoteValidator.cast_and_validate(note)
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/object_validators/types/date_time_test.exs b/test/web/activity_pub/object_validators/types/date_time_test.exs
	new file mode 100644
	index 000000000..3e17a9497
	--- /dev/null
	+++ b/test/web/activity_pub/object_validators/types/date_time_test.exs
	@@ -0,0 +1,32 @@
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTimeTest do
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTime
	+ use Pleroma.DataCase
	+
	+ test "it validates an xsd:Datetime" do
	+ valid_strings = [
	+ "2004-04-12T13:20:00",
	+ "2004-04-12T13:20:15.5",
	+ "2004-04-12T13:20:00-05:00",
	+ "2004-04-12T13:20:00Z"
	+ ]
	+
	+ invalid_strings = [
	+ "2004-04-12T13:00",
	+ "2004-04-1213:20:00",
	+ "99-04-12T13:00",
	+ "2004-04-12"
	+ ]
	+
	+ assert {:ok, "2004-04-01T12:00:00Z"} == DateTime.cast("2004-04-01T12:00:00Z")
	+
	+ Enum.each(valid_strings, fn date_time ->
	+ result = DateTime.cast(date_time)
	+ assert {:ok, _} = result
	+ end)
	+
	+ Enum.each(invalid_strings, fn date_time ->
	+ result = DateTime.cast(date_time)
	+ assert :error == result
	+ end)
	+ end
	+end
	diff --git a/test/web/activity_pub/object_validators/types/object_id_test.exs b/test/web/activity_pub/object_validators/types/object_id_test.exs
	new file mode 100644
	index 000000000..834213182
	--- /dev/null
	+++ b/test/web/activity_pub/object_validators/types/object_id_test.exs
	@@ -0,0 +1,37 @@
	+defmodule Pleroma.Web.ObjectValidators.Types.ObjectIDTest do
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types.ObjectID
	+ use Pleroma.DataCase
	+
	+ @uris [
	+ "http://lain.com/users/lain",
	+ "http://lain.com",
	+ "https://lain.com/object/1"
	+ ]
	+
	+ @non_uris [
	+ "https://",
	+ "rin",
	+ 1,
	+ :x,
	+ %{"1" => 2}
	+ ]
	+
	+ test "it accepts http uris" do
	+ Enum.each(@uris, fn uri ->
	+ assert {:ok, uri} == ObjectID.cast(uri)
	+ end)
	+ end
	+
	+ test "it accepts an object with a nested uri id" do
	+ Enum.each(@uris, fn uri ->
	+ assert {:ok, uri} == ObjectID.cast(%{"id" => uri})
	+ end)
	+ end
	+
	+ test "it rejects non-uri strings" do
	+ Enum.each(@non_uris, fn non_uri ->
	+ assert :error == ObjectID.cast(non_uri)
	+ assert :error == ObjectID.cast(%{"id" => non_uri})
	+ end)
	+ end
	+end
	diff --git a/test/web/activity_pub/pipeline_test.exs b/test/web/activity_pub/pipeline_test.exs
	new file mode 100644
	index 000000000..f3c437498
	--- /dev/null
	+++ b/test/web/activity_pub/pipeline_test.exs
	@@ -0,0 +1,87 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.PipelineTest do
	+ use Pleroma.DataCase
	+
	+ import Mock
	+ import Pleroma.Factory
	+
	+ describe "common_pipeline/2" do
	+ test "it goes through validation, filtering, persisting, side effects and federation for local activities" do
	+ activity = insert(:note_activity)
	+ meta = [local: true]
	+
	+ with_mocks([
	+ {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	+ {
	+ Pleroma.Web.ActivityPub.MRF,
	+ [],
	+ [filter: fn o -> {:ok, o} end]
	+ },
	+ {
	+ Pleroma.Web.ActivityPub.ActivityPub,
	+ [],
	+ [persist: fn o, m -> {:ok, o, m} end]
	+ },
	+ {
	+ Pleroma.Web.ActivityPub.SideEffects,
	+ [],
	+ [handle: fn o, m -> {:ok, o, m} end]
	+ },
	+ {
	+ Pleroma.Web.Federator,
	+ [],
	+ [publish: fn _o -> :ok end]
	+ }
	+ ]) do
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	+
	+ assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	+ assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	+ assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	+ assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	+ assert_called(Pleroma.Web.Federator.publish(activity))
	+ end
	+ end
	+
	+ test "it goes through validation, filtering, persisting, side effects without federation for remote activities" do
	+ activity = insert(:note_activity)
	+ meta = [local: false]
	+
	+ with_mocks([
	+ {Pleroma.Web.ActivityPub.ObjectValidator, [], [validate: fn o, m -> {:ok, o, m} end]},
	+ {
	+ Pleroma.Web.ActivityPub.MRF,
	+ [],
	+ [filter: fn o -> {:ok, o} end]
	+ },
	+ {
	+ Pleroma.Web.ActivityPub.ActivityPub,
	+ [],
	+ [persist: fn o, m -> {:ok, o, m} end]
	+ },
	+ {
	+ Pleroma.Web.ActivityPub.SideEffects,
	+ [],
	+ [handle: fn o, m -> {:ok, o, m} end]
	+ },
	+ {
	+ Pleroma.Web.Federator,
	+ [],
	+ []
	+ }
	+ ]) do
	+ assert {:ok, ^activity, ^meta} =
	+ Pleroma.Web.ActivityPub.Pipeline.common_pipeline(activity, meta)
	+
	+ assert_called(Pleroma.Web.ActivityPub.ObjectValidator.validate(activity, meta))
	+ assert_called(Pleroma.Web.ActivityPub.MRF.filter(activity))
	+ assert_called(Pleroma.Web.ActivityPub.ActivityPub.persist(activity, meta))
	+ assert_called(Pleroma.Web.ActivityPub.SideEffects.handle(activity, meta))
	+ end
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/side_effects_test.exs b/test/web/activity_pub/side_effects_test.exs
	new file mode 100644
	index 000000000..b67bd14b3
	--- /dev/null
	+++ b/test/web/activity_pub/side_effects_test.exs
	@@ -0,0 +1,34 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.ActivityPub.Builder
	+ alias Pleroma.Web.ActivityPub.SideEffects
	+ alias Pleroma.Web.CommonAPI
	+
	+ import Pleroma.Factory
	+
	+ describe "like objects" do
	+ setup do
	+ user = insert(:user)
	+ {:ok, post} = CommonAPI.post(user, %{"status" => "hey"})
	+
	+ {:ok, like_data, _meta} = Builder.like(user, post.object)
	+ {:ok, like, _meta} = ActivityPub.persist(like_data, local: true)
	+
	+ %{like: like, user: user}
	+ end
	+
	+ test "add the like to the original object", %{like: like, user: user} do
	+ {:ok, like, _} = SideEffects.handle(like)
	+ object = Object.get_by_ap_id(like.data["object"])
	+ assert object.data["like_count"] == 1
	+ assert user.ap_id in object.data["likes"]
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index b2cabbd30..6dfd823f7 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,2183 +1,2185 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

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

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", Object.normalize(activity).data)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	@tag capture_log: true
	test "it fetches reply-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)
	returned_object = Object.normalize(returned_activity, false)

	assert activity =
	Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
	end

	test "it does not fetch reply-to activities beyond max replies depth limit" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data = Map.put(data, "object", object)

	with_mock Pleroma.Web.Federator,
	allowed_thread_distance?: fn _ -> false end do
	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	returned_object = Object.normalize(returned_activity, false)

	refute Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_object.data["inReplyToAtomUri"] ==
	"https://shitposter.club/notice/2827873"
	end
	end

	test "it does not crash if the object in inReplyTo can't be fetched" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://404.site/whatever")

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

	assert capture_log(fn ->
	{:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
	end) =~ "[error] Couldn't fetch \"https://404.site/whatever\", error: nil"
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object_data = Object.normalize(data["object"]).data

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object_data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object_data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object_data["actor"] == "http://mastodon.example.org/users/admin"
	assert object_data["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object_data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object_data["sensitive"] == true

	user = User.get_cached_by_ap_id(object_data["actor"])

	assert user.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert Enum.at(object.data["tag"], 2) == "moo"
	end

	test "it works for incoming questions" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert Enum.all?(object.data["oneOf"], fn choice ->
	choice["name"] in [
	"Dunno",
	"Everyone knows that!",
	"25 char limit is dumb",
	"I can't even fit a funny"
	]
	end)
	end

	test "it works for incoming listens" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Listen",
	"id" => "http://mastodon.example.org/users/admin/listens/1234/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"object" => %{
	"type" => "Audio",
	"id" => "http://mastodon.example.org/users/admin/listens/1234",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"title" => "lain radio episode 1",
	"artist" => "lain",
	"album" => "lain radio",
	"length" => 180_000
	}
	}

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"
	assert object.data["artist"] == "lain"
	assert object.data["album"] == "lain radio"
	assert object.data["length"] == 180_000
	end

	test "it rewrites Note votes to Answers and increments vote counters on question activities" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	object = Object.normalize(activity)

	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	answer_object = Object.normalize(activity)
	assert answer_object.data["type"] == "Answer"
	object = Object.get_by_ap_id(object.data["id"])

	assert Enum.any?(
	object.data["oneOf"],
	fn
	%{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
	_ -> false
	end
	)
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert "test" in object.data["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(data["object"])

	assert object.data["url"] == "https://prismo.news/posts/83"
	end

	test "it cleans up incoming notices which are not really DMs" do
	user = insert(:user)
	other_user = insert(:user)

	to = [user.ap_id, other_user.ap_id]

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert data["to"] == []
	assert data["cc"] == to

	object_data = Object.normalize(activity).data

	assert object_data["to"] == []
	assert object_data["cc"] == to
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	- {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ {:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)
	+
	+ refute Enum.empty?(activity.recipients)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]
	end

	test "it works for incoming misskey likes, turning them into EmojiReacts" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/misskey-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == data["actor"]
	assert data["type"] == "EmojiReact"
	assert data["id"] == data["id"]
	assert data["object"] == activity.data["object"]
	assert data["content"] == "🍮"
	end

	test "it works for incoming misskey likes that contain unicode emojis, turning them into EmojiReacts" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/misskey-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])
	\|> Map.put("_misskey_reaction", "⭐")

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == data["actor"]
	assert data["type"] == "EmojiReact"
	assert data["id"] == data["id"]
	assert data["object"] == activity.data["object"]
	assert data["content"] == "⭐"
	end

	test "it works for incoming emoji reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "EmojiReact"
	assert data["id"] == "http://mastodon.example.org/users/admin#reactions/2"
	assert data["object"] == activity.data["object"]
	assert data["content"] == "👌"
	end

	test "it reject invalid emoji reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/emoji-reaction-too-long.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	assert :error = Transmogrifier.handle_incoming(data)

	data =
	File.read!("test/fixtures/emoji-reaction-no-emoji.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	assert :error = Transmogrifier.handle_incoming(data)
	end

	test "it works for incoming emoji reaction undos" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
	{:ok, reaction_activity, _object} = CommonAPI.react_with_emoji(activity.id, user, "👌")

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", reaction_activity.data["id"])
	\|> Map.put("actor", user.ap_id)

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

	assert activity.actor == user.ap_id
	assert activity.data["id"] == data["id"]
	assert activity.data["type"] == "Undo"
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming unlikes with an existing like activity and a compact object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data["id"])
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] == activity.data["object"]

	assert Activity.get_create_by_object_ap_id(data["object"]).id == activity.id
	end

	test "it works for incoming announces with an inlined activity" do
	data =
	File.read!("test/fixtures/mastodon-announce-private.json")
	\|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	object = Object.normalize(data["object"])

	assert object.data["id"] == "http://mastodon.example.org/@admin/99541947525187368"
	assert object.data["content"] == "this is a private toot"
	end

	@tag capture_log: true
	test "it rejects incoming announces with an inlined activity from another origin" do
	data =
	File.read!("test/fixtures/bogus-mastodon-announce.json")
	\|> Poison.decode!()

	assert :error = Transmogrifier.handle_incoming(data)
	end

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", Object.normalize(activity).data["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)
	\|> Map.put("id", user.ap_id <> "/activities/12345678")

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert !is_nil(data["to"])
	assert !is_nil(data["cc"])
	end

	test "it strips internal likes" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	likes = %{
	"first" =>
	"http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
	"id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
	"totalItems" => 3,
	"type" => "OrderedCollection"
	}

	object = Map.put(data["object"], "likes", likes)
	data = Map.put(data, "object", object)

	{:ok, %Activity{object: object}} = Transmogrifier.handle_incoming(data)

	refute Map.has_key?(object.data, "likes")
	end

	test "it strips internal reactions" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
	{:ok, _, _} = CommonAPI.react_with_emoji(activity.id, user, "📢")

	%{object: object} = Activity.get_by_id_with_object(activity.id)
	assert Map.has_key?(object.data, "reactions")
	assert Map.has_key?(object.data, "reaction_count")

	object_data = Transmogrifier.strip_internal_fields(object.data)
	refute Map.has_key?(object_data, "reactions")
	refute Map.has_key?(object_data, "reaction_count")
	end

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	assert data["id"] == update_data["id"]

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works with alsoKnownAs" do
	{:ok, %Activity{data: %{"actor" => actor}}} =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == ["http://example.org/users/foo"]

	{:ok, _activity} =
	"test/fixtures/mastodon-update.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Map.put("actor", actor)
	\|> Map.update!("object", fn object ->
	object
	\|> Map.put("actor", actor)
	\|> Map.put("id", actor)
	\|> Map.put("alsoKnownAs", [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	])
	end)
	\|> Transmogrifier.handle_incoming()

	assert User.get_cached_by_ap_id(actor).also_known_as == [
	"http://mastodon.example.org/users/foo",
	"http://example.org/users/bar"
	]
	end

	test "it works with custom profile fields" do
	{:ok, activity} =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Poison.decode!()
	\|> Transmogrifier.handle_incoming()

	user = User.get_cached_by_ap_id(activity.actor)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "foo1", "value" => "bar1"}
	]

	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("id", user.ap_id)

	update_data =
	update_data
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("object", object)

	{:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	Pleroma.Config.put([:instance, :max_remote_account_fields], 2)

	update_data =
	put_in(update_data, ["object", "attachment"], [
	%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
	%{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
	%{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
	])

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert User.fields(user) == [
	%{"name" => "foo", "value" => "updated"},
	%{"name" => "foo1", "value" => "updated"}
	]

	update_data = put_in(update_data, ["object", "attachment"], [])

	{:ok, _} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert User.fields(user) == []
	end

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)
	deleting_user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", deleting_user.ap_id)

	{:ok, %Activity{actor: actor, local: false, data: %{"id" => id}}} =
	Transmogrifier.handle_incoming(data)

	assert id == data["id"]
	refute Activity.get_by_id(activity.id)
	assert actor == deleting_user.ap_id
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"])

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

	assert capture_log(fn ->
	:error = Transmogrifier.handle_incoming(data)
	end) =~
	"[error] Could not decode user at fetch http://mastodon.example.org/users/gargron, {:error, :nxdomain}"

	assert Activity.get_by_id(activity.id)
	end

	@tag capture_log: true
	test "it works for incoming user deletes" do
	%{ap_id: ap_id} = insert(:user, ap_id: "http://mastodon.example.org/users/admin")

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	\|> Poison.decode!()

	{:ok, _} = Transmogrifier.handle_incoming(data)
	ObanHelpers.perform_all()

	refute User.get_cached_by_ap_id(ap_id)
	end

	test "it fails for incoming user deletes with spoofed origin" do
	%{ap_id: ap_id} = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-delete-user.json")
	\|> Poison.decode!()
	\|> Map.put("actor", ap_id)

	assert capture_log(fn ->
	assert :error == Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"

	assert User.get_cached_by_ap_id(ap_id)
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: announce_data, local: false}} =
	Transmogrifier.handle_incoming(announce_data)

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert object_data = data["object"]
	assert object_data["type"] == "Announce"
	assert object_data["object"] == activity.data["object"]

	assert object_data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follows to locked account" do
	pending_follower = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
	user = insert(:user, locked: true)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Follow"
	assert data["object"] == user.ap_id
	assert data["state"] == "pending"
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	assert [^pending_follower] = User.get_follow_requests(user)
	end

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	assert activity.data["id"] == accept_data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local
	assert activity.data["id"] == reject_data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

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

	note_obj = %{
	"type" => "Note",
	"id" => activity.data["id"],
	"content" => "test post",
	"published" => object.data["published"],
	"actor" => AccountView.render("show.json", %{user: user})
	}

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

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

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it correctly processes messages with non-array to field" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"type" => "Create",
	"object" => %{
	"content" => "blah blah blah",
	"type" => "Note",
	"attributedTo" => user.ap_id,
	"inReplyTo" => nil
	},
	"actor" => user.ap_id
	}

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

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
	end

	test "it correctly processes messages with non-array cc field" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => user.follower_address,
	"cc" => "https://www.w3.org/ns/activitystreams#Public",
	"type" => "Create",
	"object" => %{
	"content" => "blah blah blah",
	"type" => "Note",
	"attributedTo" => user.ap_id,
	"inReplyTo" => nil
	},
	"actor" => user.ap_id
	}

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

	assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["cc"]
	assert [user.follower_address] == activity.data["to"]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end
	end

	describe "`handle_incoming/2`, Mastodon format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data =
	"test/fixtures/mastodon-post-activity.json"
	\|> File.read!()
	\|> Poison.decode!()

	items = get_in(data, ["object", "replies", "first", "items"])
	assert length(items) > 0

	%{data: data, items: items}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	data: data,
	items: items
	} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 10)

	{:ok, _activity} = Transmogrifier.handle_incoming(data)

	for id <- items do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{data: data} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(data)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "`handle_incoming/2`, Pleroma format `replies` handling" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	user = insert(:user)

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

	{:ok, reply1} =
	CommonAPI.post(user, %{"status" => "reply1", "in_reply_to_status_id" => activity.id})

	{:ok, reply2} =
	CommonAPI.post(user, %{"status" => "reply2", "in_reply_to_status_id" => activity.id})

	replies_uris = Enum.map([reply1, reply2], fn a -> a.object.data["id"] end)

	{:ok, federation_output} = Transmogrifier.prepare_outgoing(activity.data)

	Repo.delete(activity.object)
	Repo.delete(activity)

	%{federation_output: federation_output, replies_uris: replies_uris}
	end

	test "schedules background fetching of `replies` items if max thread depth limit allows", %{
	federation_output: federation_output,
	replies_uris: replies_uris
	} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 1)

	{:ok, _activity} = Transmogrifier.handle_incoming(federation_output)

	for id <- replies_uris do
	job_args = %{"op" => "fetch_remote", "id" => id, "depth" => 1}
	assert_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker, args: job_args)
	end
	end

	test "does NOT schedule background fetching of `replies` beyond max thread depth limit allows",
	%{federation_output: federation_output} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)

	{:ok, _activity} = Transmogrifier.handle_incoming(federation_output)

	assert all_enqueued(worker: Pleroma.Workers.RemoteFetcherWorker) == []
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey", "visibility" => "private"})

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] ==
	Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

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

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert is_nil(modified["bcc"])
	end

	test "it can handle Listen activities" do
	listen_activity = insert(:listen)

	{:ok, modified} = Transmogrifier.prepare_outgoing(listen_activity.data)

	assert modified["type"] == "Listen"

	user = insert(:user)

	{:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})

	{:ok, _modified} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user)
	Pleroma.FollowingRelationship.follow(user_two, user, "accept")

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	ObanHelpers.perform_all()

	assert user.ap_enabled
	assert user.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"
	assert user.following_address == "https://niu.moe/users/rye/following"

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 1

	activity = Activity.get_by_id(activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.banner

	refute "..." in activity.recipients

	unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_cached_by_id(user_two.id)
	assert User.following?(user_two, user)
	refute "..." in User.following(user_two)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	:error = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	:error = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	:error = Transmogrifier.handle_incoming(data)
	end) =~ "Object containment failed"
	end
	end

	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

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

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end

	test "Rewrites Answers to Notes" do
	user = insert(:user)

	{:ok, poll_activity} =
	CommonAPI.post(user, %{
	"status" => "suya...",
	"poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
	})

	poll_object = Object.normalize(poll_activity)
	# TODO: Replace with CommonAPI vote creation when implemented
	data =
	File.read!("test/fixtures/mastodon-vote.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["to"], user.ap_id)
	\|> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
	\|> Kernel.put_in(["object", "to"], user.ap_id)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	assert data["object"]["type"] == "Note"
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_in_reply_to/2" do
	setup do: clear_config([:instance, :federation_incoming_replies_max_depth])

	setup do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	[data: data]
	end

	test "returns not modified object when hasn't containts inReplyTo field", %{data: data} do
	assert Transmogrifier.fix_in_reply_to(data) == data
	end

	test "returns object with inReplyToAtomUri when denied incoming reply", %{data: data} do
	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)

	object_with_reply =
	Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", %{"id" => "https://shitposter.club/notice/2827873"})

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == %{"id" => "https://shitposter.club/notice/2827873"}
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply =
	Map.put(data["object"], "inReplyTo", ["https://shitposter.club/notice/2827873"])

	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == ["https://shitposter.club/notice/2827873"]
	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	object_with_reply = Map.put(data["object"], "inReplyTo", [])
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
	assert modified_object["inReplyTo"] == []
	assert modified_object["inReplyToAtomUri"] == ""
	end

	@tag capture_log: true
	test "returns modified object when allowed incoming reply", %{data: data} do
	object_with_reply =
	Map.put(
	data["object"],
	"inReplyTo",
	"https://shitposter.club/notice/2827873"
	)

	Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 5)
	modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)

	assert modified_object["inReplyTo"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"

	assert modified_object["conversation"] ==
	"tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"

	assert modified_object["context"] ==
	"tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "fixes data for video object" do
	object = %{
	"type" => "Video",
	"url" => [
	%{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	},
	%{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peertube46fb-ad81-2d4c2d1630e3-240.mp4"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d1630e3"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d16377-42"
	}
	]
	}

	assert Transmogrifier.fix_url(object) == %{
	"attachment" => [
	%{
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"type" => "Link"
	}
	],
	"type" => "Video",
	"url" => "https://peertube.-2d4c2d1630e3"
	}
	end

	test "fixes url for not Video object" do
	object = %{
	"type" => "Text",
	"url" => [
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d1630e3"
	},
	%{
	"type" => "Link",
	"mimeType" => "text/html",
	"href" => "https://peertube.-2d4c2d16377-42"
	}
	]
	}

	assert Transmogrifier.fix_url(object) == %{
	"type" => "Text",
	"url" => "https://peertube.-2d4c2d1630e3"
	}

	assert Transmogrifier.fix_url(%{"type" => "Text", "url" => []}) == %{
	"type" => "Text",
	"url" => ""
	}
	end

	test "retunrs not modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	end) =~ "Unsupported URI scheme"
	end

	@tag capture_log: true
	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper("https://shitposter.club/notice/2827873")
	end
	end

	describe "fix_attachments/1" do
	test "returns not modified object" do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_attachments(data) == data
	end

	test "returns modified object when attachment is map" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => %{
	"mediaType" => "video/mp4",
	"url" => "https://peertube.moe/stat-480.mp4"
	}
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://peertube.moe/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end

	test "returns modified object when attachment is list" do
	assert Transmogrifier.fix_attachments(%{
	"attachment" => [
	%{"mediaType" => "video/mp4", "url" => "https://pe.er/stat-480.mp4"},
	%{"mimeType" => "video/mp4", "href" => "https://pe.er/stat-480.mp4"}
	]
	}) == %{
	"attachment" => [
	%{
	"mediaType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	},
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"mimeType" => "video/mp4",
	"url" => [
	%{
	"href" => "https://pe.er/stat-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	]
	}
	end
	end

	describe "fix_emoji/1" do
	test "returns not modified object when object not contains tags" do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.fix_emoji(data) == data
	end

	test "returns object with emoji when object contains list tags" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => [
	%{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}},
	%{"type" => "Hashtag"}
	]
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => [
	%{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"},
	%{"type" => "Hashtag"}
	]
	}
	end

	test "returns object with emoji when object contains map tag" do
	assert Transmogrifier.fix_emoji(%{
	"tag" => %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}}
	}) == %{
	"emoji" => %{"bib" => "/test"},
	"tag" => %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"}
	}
	end
	end

	describe "set_replies/1" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 2)

	test "returns unmodified object if activity doesn't have self-replies" do
	data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
	assert Transmogrifier.set_replies(data) == data
	end

	test "sets `replies` collection with a limited number of self-replies" do
	[user, another_user] = insert_list(2, :user)

	{:ok, %{id: id1} = activity} = CommonAPI.post(user, %{"status" => "1"})

	{:ok, %{id: id2} = self_reply1} =
	CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => id1})

	{:ok, self_reply2} =
	CommonAPI.post(user, %{"status" => "self-reply 2", "in_reply_to_status_id" => id1})

	# Assuming to _not_ be present in `replies` due to :note_replies_output_limit is set to 2
	{:ok, _} =
	CommonAPI.post(user, %{"status" => "self-reply 3", "in_reply_to_status_id" => id1})

	{:ok, _} =
	CommonAPI.post(user, %{
	"status" => "self-reply to self-reply",
	"in_reply_to_status_id" => id2
	})

	{:ok, _} =
	CommonAPI.post(another_user, %{
	"status" => "another user's reply",
	"in_reply_to_status_id" => id1
	})

	object = Object.normalize(activity)
	replies_uris = Enum.map([self_reply1, self_reply2], fn a -> a.object.data["id"] end)

	assert %{"type" => "Collection", "items" => ^replies_uris} =
	Transmogrifier.set_replies(object.data)["replies"]
	end
	end
	end
	diff --git a/test/web/activity_pub/views/object_view_test.exs b/test/web/activity_pub/views/object_view_test.exs
	index de5ffc5b3..6c006206b 100644
	--- a/test/web/activity_pub/views/object_view_test.exs
	+++ b/test/web/activity_pub/views/object_view_test.exs
	@@ -1,84 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory

	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.CommonAPI

	test "renders a note object" do
	note = insert(:note)

	result = ObjectView.render("object.json", %{object: note})

	assert result["id"] == note.data["id"]
	assert result["to"] == note.data["to"]
	assert result["content"] == note.data["content"]
	assert result["type"] == "Note"
	assert result["@context"]
	end

	test "renders a note activity" do
	note = insert(:note_activity)
	object = Object.normalize(note)

	result = ObjectView.render("object.json", %{object: note})

	assert result["id"] == note.data["id"]
	assert result["to"] == note.data["to"]
	assert result["object"]["type"] == "Note"
	assert result["object"]["content"] == object.data["content"]
	assert result["type"] == "Create"
	assert result["@context"]
	end

	describe "note activity's `replies` collection rendering" do
	setup do: clear_config([:activitypub, :note_replies_output_limit], 5)

	test "renders `replies` collection for a note activity" do
	user = insert(:user)
	activity = insert(:note_activity, user: user)

	{:ok, self_reply1} =
	CommonAPI.post(user, %{"status" => "self-reply 1", "in_reply_to_status_id" => activity.id})

	replies_uris = [self_reply1.object.data["id"]]
	result = ObjectView.render("object.json", %{object: refresh_record(activity)})

	assert %{"type" => "Collection", "items" => ^replies_uris} =
	get_in(result, ["object", "replies"])
	end
	end

	test "renders a like activity" do
	note = insert(:note_activity)
	object = Object.normalize(note)
	user = insert(:user)

	- {:ok, like_activity, _} = CommonAPI.favorite(note.id, user)
	+ {:ok, like_activity} = CommonAPI.favorite(user, note.id)

	result = ObjectView.render("object.json", %{object: like_activity})

	assert result["id"] == like_activity.data["id"]
	assert result["object"] == object.data["id"]
	assert result["type"] == "Like"
	end

	test "renders an announce activity" do
	note = insert(:note_activity)
	object = Object.normalize(note)
	user = insert(:user)

	{:ok, announce_activity, _} = CommonAPI.repeat(note.id, user)

	result = ObjectView.render("object.json", %{object: announce_activity})

	assert result["id"] == announce_activity.data["id"]
	assert result["object"] == object.data["id"]
	assert result["type"] == "Announce"
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index 0da0bd2e2..f46ad0272 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,702 +1,705 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{"status" => ".", "in_reply_to_conversation_id" => participation.id})

	assert Visibility.is_direct?(convo_reply)

	assert activity.data["context"] == convo_reply.data["context"]
	end

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey",
	"visibility" => "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "I don't really like @#{tridi.nickname}",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity.id,
	"in_reply_to_conversation_id" => participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	"visibility" => "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})

	object = Object.normalize(activity)

	assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})

	assert Object.normalize(activity).data["emoji"]["firefox"]
	end

	test "it adds emoji when updating profiles" do
	user = insert(:user, %{name: ":firefox:"})

	{:ok, activity} = CommonAPI.update(user)
	user = User.get_cached_by_ap_id(user.ap_id)
	[firefox] = user.source_data["tag"]

	assert firefox["name"] == ":firefox:"

	assert Pleroma.Constants.as_public() in activity.recipients
	end

	describe "posting" do
	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	"to" => [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/html"
	})

	object = Object.normalize(activity)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/markdown"
	})

	object = Object.normalize(activity)

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => visibility,
	"in_reply_to_status_id" => activity.id
	})
	end)
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{"status" => ""})
	end

	test "it validates character limits are correctly enforced" do
	Pleroma.Config.put([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{"status" => "foobar"})

	assert {:ok, activity} = CommonAPI.post(user, %{"status" => "12345"})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)
	\|> NaiveDateTime.add(1_000_000, :second)

	assert {:ok, activity} =
	CommonAPI.post(user, %{"status" => "chai", "expires_in" => 1_000_000})

	assert expiration = Pleroma.ActivityExpiration.get_by_activity_id(activity.id)
	assert expiration.scheduled_at == expires_at
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, reaction, _} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, reaction, _} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction, _} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{} = announce_activity, _} =
	CommonAPI.repeat(activity.id, user, %{"visibility" => "private"})

	assert Visibility.is_private?(announce_activity)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	- {:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	+ {:ok, post_activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	- {:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
	+ {:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
	+ assert data["type"] == "Like"
	+ assert data["actor"] == user.ap_id
	+ assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{} = activity, object} = CommonAPI.repeat(activity.id, user)
	{:ok, ^activity, ^object} = CommonAPI.repeat(activity.id, user)
	end

	- test "favoriting a status twice returns the status" do
	+ test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	- {:ok, %Activity{} = activity, object} = CommonAPI.favorite(activity.id, user)
	- {:ok, ^activity, ^object} = CommonAPI.favorite(activity.id, user)
	+ {:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
	+ assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
	end
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

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

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "How is fediverse today?",
	"poll" => %{"options" => ["Absolutely outstanding", "Not good"], "expires_in" => 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!", "visibility" => "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

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

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	"account_id" => target_user.id,
	"comment" => comment,
	"status_ids" => [activity.id]
	}

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => "foobar",
	"published" => activity.object.data["published"],
	"actor" => AccountView.render("show.json", %{user: target_user})
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, activity_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert activity_id == activity.data["id"]
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel very offended!",
	"status_ids" => [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.subscribed_to?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, locked: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == "pending"
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, locked: true, local: false, ap_enabled: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == "pending"
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
	{:ok, follow_activity_three} = ActivityPub.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Am I cute?",
	"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	{:ok, _, object} = CommonAPI.vote(other_user, object, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	"title" => "lain radio episode 1",
	"album" => "lain radio",
	"artist" => "lain",
	"length" => 180_000
	})

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	"title" => "lain radio episode 1",
	"album" => "lain radio",
	"artist" => "lain",
	"length" => 180_000,
	"visibility" => "private"
	})

	object = Object.normalize(activity)

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end
	end
	diff --git a/test/web/mastodon_api/controllers/notification_controller_test.exs b/test/web/mastodon_api/controllers/notification_controller_test.exs
	index 23f94e3a6..344eabb4a 100644
	--- a/test/web/mastodon_api/controllers/notification_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/notification_controller_test.exs
	@@ -1,544 +1,544 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

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

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

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

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

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

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

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

	conn = get(conn, "/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification" do
	%{user: user, conn: conn} = oauth_access(["write:notifications"])
	other_user = insert(:user)

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications" do
	%{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
	other_user = insert(:user)

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

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

	ret_conn = post(conn, "/api/v1/notifications/clear")

	assert %{} = json_response(ret_conn, 200)

	ret_conn = get(conn, "/api/v1/notifications")

	assert all = json_response(ret_conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	conn = assign(conn, :user, user)

	# min_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	describe "exclude_visibilities" do
	test "filters notifications for mentions" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, public_activity} =
	CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})

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

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})

	{:ok, private_activity} =
	CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})

	conn_res =
	get(conn, "/api/v1/notifications", %{
	exclude_visibilities: ["public", "unlisted", "private"]
	})

	assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	assert id == direct_activity.id

	conn_res =
	get(conn, "/api/v1/notifications", %{
	exclude_visibilities: ["public", "unlisted", "direct"]
	})

	assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	assert id == private_activity.id

	conn_res =
	get(conn, "/api/v1/notifications", %{
	exclude_visibilities: ["public", "private", "direct"]
	})

	assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	assert id == unlisted_activity.id

	conn_res =
	get(conn, "/api/v1/notifications", %{
	exclude_visibilities: ["unlisted", "private", "direct"]
	})

	assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	assert id == public_activity.id
	end

	test "filters notifications for Like activities" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, public_activity} =
	CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})

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

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})

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

	- {:ok, _, _} = CommonAPI.favorite(public_activity.id, user)
	- {:ok, _, _} = CommonAPI.favorite(direct_activity.id, user)
	- {:ok, _, _} = CommonAPI.favorite(unlisted_activity.id, user)
	- {:ok, _, _} = CommonAPI.favorite(private_activity.id, user)
	+ {:ok, _} = CommonAPI.favorite(user, public_activity.id)
	+ {:ok, _} = CommonAPI.favorite(user, direct_activity.id)
	+ {:ok, _} = CommonAPI.favorite(user, unlisted_activity.id)
	+ {:ok, _} = CommonAPI.favorite(user, private_activity.id)

	activity_ids =
	conn
	\|> get("/api/v1/notifications", %{exclude_visibilities: ["direct"]})
	\|> json_response(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	refute direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
	\|> json_response(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	refute unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	assert direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications", %{exclude_visibilities: ["private"]})
	\|> json_response(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	refute private_activity.id in activity_ids
	assert direct_activity.id in activity_ids

	activity_ids =
	conn
	\|> get("/api/v1/notifications", %{exclude_visibilities: ["public"]})
	\|> json_response(200)
	\|> Enum.map(& &1["status"]["id"])

	refute public_activity.id in activity_ids
	assert unlisted_activity.id in activity_ids
	assert private_activity.id in activity_ids
	assert direct_activity.id in activity_ids
	end

	test "filters notifications for Announce activities" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, public_activity} =
	CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})

	{:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
	{:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)

	activity_ids =
	conn
	\|> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
	\|> json_response(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	refute unlisted_activity.id in activity_ids
	end
	end

	test "filters notifications using exclude_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	- {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
	+ {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
	{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)

	mention_notification_id = get_notification_id_by_activity(mention_activity)
	favorite_notification_id = get_notification_id_by_activity(favorite_activity)
	reblog_notification_id = get_notification_id_by_activity(reblog_activity)
	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
	end

	test "filters notifications using include_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	- {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
	+ {:ok, favorite_activity} = CommonAPI.favorite(other_user, create_activity.id)
	{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)

	mention_notification_id = get_notification_id_by_activity(mention_activity)
	favorite_notification_id = get_notification_id_by_activity(favorite_activity)
	reblog_notification_id = get_notification_id_by_activity(reblog_activity)
	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn_res = get(conn, "/api/v1/notifications", %{include_types: ["follow"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications", %{include_types: ["mention"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications", %{include_types: ["favourite"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications", %{include_types: ["reblog"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)

	result = conn \|> get("/api/v1/notifications") \|> json_response(200)

	assert length(result) == 4

	result =
	conn
	\|> get("/api/v1/notifications", %{
	include_types: ["follow", "mention", "favourite", "reblog"]
	})
	\|> json_response(200)

	assert length(result) == 4
	end

	test "destroy multiple" do
	%{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
	{:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	conn_destroy =
	conn
	\|> delete("/api/v1/notifications/destroy_multiple", %{
	"ids" => [notification1_id, notification2_id]
	})

	assert json_response(conn_destroy, 200) == %{}

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end

	test "doesn't see notifications after muting user with notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response(ret_conn, 200)) == 1

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

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

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

	test "see notifications after muting user without notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response(ret_conn, 200)) == 1

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

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

	assert length(json_response(conn, 200)) == 1
	end

	test "see notifications after muting user with notifications and with_muted parameter" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response(ret_conn, 200)) == 1

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

	conn = get(conn, "/api/v1/notifications", %{"with_muted" => "true"})

	assert length(json_response(conn, 200)) == 1
	end

	@tag capture_log: true
	test "see move notifications" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	%{user: follower, conn: conn} = oauth_access(["read:notifications"])

	old_user_url = old_user.ap_id

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", old_user.nickname)
	\|> Jason.encode!()

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

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

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

	assert length(json_response(conn, 200)) == 1
	end

	describe "link headers" do
	test "preserves parameters in link headers" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

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

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

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{media_only: true})

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/media_only=true/
	assert link_header =~ ~r/min_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	describe "from specified user" do
	test "account_id" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])

	%{id: account_id} = other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, _activity} = CommonAPI.post(other_user1, %{"status" => "hi @#{user.nickname}"})
	{:ok, _activity} = CommonAPI.post(other_user2, %{"status" => "bye @#{user.nickname}"})

	assert [%{"account" => %{"id" => ^account_id}}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{account_id: account_id})
	\|> json_response(200)

	assert %{"error" => "Account is not found"} =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{account_id: "cofe"})
	\|> json_response(404)
	end
	end

	defp get_notification_id_by_activity(%{id: id}) do
	Notification
	\|> Repo.get_by(activity_id: id)
	\|> Map.get(:id)
	\|> to_string()
	end
	end
	diff --git a/test/web/mastodon_api/controllers/status_controller_test.exs b/test/web/mastodon_api/controllers/status_controller_test.exs
	index d59974d50..cd9ca4973 100644
	--- a/test/web/mastodon_api/controllers/status_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/status_controller_test.exs
	@@ -1,1451 +1,1455 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup do: clear_config([:instance, :federating])
	setup do: clear_config([:instance, :allow_relay])
	setup do: clear_config([:rich_media, :enabled])

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

	test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
	Pleroma.Config.put([:instance, :federating], true)
	Pleroma.Config.get([:instance, :allow_relay], true)

	response =
	conn
	\|> post("api/v1/statuses", %{
	"content_type" => "text/plain",
	"source" => "Pleroma FE",
	"status" => "Hello world",
	"visibility" => "public"
	})
	\|> json_response(200)

	assert response["reblogs_count"] == 0
	ObanHelpers.perform_all()

	response =
	conn
	\|> get("api/v1/statuses/#{response["id"]}", %{})
	\|> json_response(200)

	assert response["reblogs_count"] == 0
	end

	test "posting a status", %{conn: conn} do
	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)
	assert id == second_id

	conn_three =
	conn
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)
	refute id == third_id

	# An activity that will expire:
	# 2 hours
	expires_in = 120 * 60

	conn_four =
	conn
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})

	assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
	assert activity = Activity.get_by_id(fourth_id)
	assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)

	estimated_expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(expires_in)
	\|> NaiveDateTime.truncate(:second)

	# This assert will fail if the test takes longer than a minute. I sure hope it never does:
	assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60

	assert fourth_response["pleroma"]["expires_at"] ==
	NaiveDateTime.to_iso8601(expiration.scheduled_at)
	end

	test "it fails to create a status if `expires_in` is less or equal than an hour", %{
	conn: conn
	} do
	# 1 hour
	expires_in = 60 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response(422)

	# 30 minutes
	expires_in = 30 * 60

	assert %{"error" => "Expiry date is too soon"} =
	conn
	\|> post("api/v1/statuses", %{
	"status" => "oolong",
	"expires_in" => expires_in
	})
	\|> json_response(422)
	end

	test "posting an undefined status with an attachment", %{user: user, conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

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

	conn =
	post(conn, "/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)]
	})

	assert json_response(conn, 200)
	end

	test "replying to a status", %{user: user, conn: conn} do
	{:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})

	conn =
	conn
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
	end

	test "replying to a direct message with visibility other than direct", %{
	user: user,
	conn: conn
	} do
	{:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	conn =
	conn
	\|> post("/api/v1/statuses", %{
	"status" => "@#{user.nickname} hey",
	"in_reply_to_id" => replied_to.id,
	"visibility" => visibility
	})

	assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
	end)
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	conn = post(conn, "/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a sensitive status", %{conn: conn} do
	conn = post(conn, "/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	real_conn =
	post(conn, "/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	post(conn, "/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	Config.put([:rich_media, :enabled], true)

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "https://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a direct status", %{conn: conn} do
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn = post(conn, "api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id} = response = json_response(conn, 200)
	assert response["visibility"] == "direct"
	assert response["pleroma"]["direct_conversation_id"]
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end
	end

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

	test "creates a scheduled activity", %{conn: conn} do
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
	assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

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

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

	conn =
	post(conn, "/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn = post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
	end
	end

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

	test "posting a poll", %{conn: conn} do
	time = NaiveDateTime.utc_now()

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "Who is the #bestgrill?",
	"poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
	})

	response = json_response(conn, 200)

	assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
	title in ["Rei", "Asuka", "Misato"]
	end)

	assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
	refute response["poll"]["expred"]

	question = Object.get_by_id(response["poll"]["id"])

	# closed contains utc timezone
	assert question.data["closed"] =~ "Z"
	end

	test "option limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_options])

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Poll can't contain more than #{limit} options"
	end

	test "option character limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_option_chars])

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "...",
	"poll" => %{
	"options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
	"expires_in" => 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Poll options cannot be longer than #{limit} characters each"
	end

	test "minimal date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :min_expiration])

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit - 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Expiration date is too soon"
	end

	test "maximum date limit is enforced", %{conn: conn} do
	limit = Config.get([:instance, :poll_limits, :max_expiration])

	conn =
	post(conn, "/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit + 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Expiration date is too far in the future"
	end
	end

	test "get a status" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

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

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	defp local_and_remote_activities do
	local = insert(:note_activity)
	remote = insert(:note_activity, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "status with restrict unauthenticated activities for local and remote" do
	setup do: local_and_remote_activities()

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

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

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

	assert json_response(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

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

	assert json_response(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response(res_conn, 200)

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

	describe "status with restrict unauthenticated activities for local" do
	setup do: local_and_remote_activities()

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

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

	assert json_response(res_conn, :not_found) == %{
	"error" => "Record not found"
	}

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

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response(res_conn, 200)

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

	describe "status with restrict unauthenticated activities for remote" do
	setup do: local_and_remote_activities()

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

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

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

	assert json_response(res_conn, :not_found) == %{
	"error" => "Record not found"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])
	res_conn = get(conn, "/api/v1/statuses/#{local.id}")
	assert %{"id" => _} = json_response(res_conn, 200)

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

	test "getting a status that doesn't exist returns 404" do
	%{conn: conn} = oauth_access(["read:statuses"])
	activity = insert(:note_activity)

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

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end

	test "get a direct status" do
	%{user: user, conn: conn} = oauth_access(["read:statuses"])
	other_user = insert(:user)

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}")

	[participation] = Participation.for_user(user)

	res = json_response(conn, 200)
	assert res["pleroma"]["direct_conversation_id"] == participation.id
	end

	test "get statuses by IDs" do
	%{conn: conn} = oauth_access(["read:statuses"])
	%{id: id1} = insert(:note_activity)
	%{id: id2} = insert(:note_activity)

	query_string = "ids[]=#{id1}&ids[]=#{id2}"
	conn = get(conn, "/api/v1/statuses/?#{query_string}")

	assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
	end

	describe "getting statuses by ids with restricted unauthenticated for local and remote" do
	setup do: local_and_remote_activities()

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

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

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

	assert json_response(res_conn, 200) == []
	end

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

	res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})

	assert length(json_response(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for local" do
	setup do: local_and_remote_activities()

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

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

	remote_id = remote.id
	assert [%{"id" => ^remote_id}] = json_response(res_conn, 200)
	end

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

	res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})

	assert length(json_response(res_conn, 200)) == 2
	end
	end

	describe "getting statuses by ids with restricted unauthenticated for remote" do
	setup do: local_and_remote_activities()

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

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

	local_id = local.id
	assert [%{"id" => ^local_id}] = json_response(res_conn, 200)
	end

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

	res_conn = get(conn, "/api/v1/statuses", %{ids: [local.id, remote.id]})

	assert length(json_response(res_conn, 200)) == 2
	end
	end

	describe "deleting a status" do
	test "when you created it" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Activity.get_by_id(activity.id)
	end

	test "when it doesn't exist" do
	%{user: author, conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity, user: author)

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{String.downcase(activity.id)}")

	assert %{"error" => "Record not found"} == json_response(conn, 404)
	end

	test "when you didn't create it" do
	%{conn: conn} = oauth_access(["write:statuses"])
	activity = insert(:note_activity)

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

	assert %{"error" => _} = json_response(conn, 403)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, is_admin: true)
	moderator = insert(:user, is_moderator: true)

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

	assert %{} = json_response(res_conn, 200)

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

	assert %{} = json_response(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

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

	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)

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

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true
	} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
	activity = insert(:note_activity)

	conn = post(conn, "/api/v1/statuses/#{String.downcase(activity.id)}/reblog")

	assert %{"error" => "Record not found"} = json_response(conn, 404)
	end

	test "reblogs privately and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)

	conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog", %{"visibility" => "private"})

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true,
	"visibility" => "private"
	} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "reblogged status for another user" do
	activity = insert(:note_activity)
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	- CommonAPI.favorite(activity.id, user2)
	+ {:ok, _} = CommonAPI.favorite(user2, activity.id)
	{:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
	{:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
	{:ok, _, _object} = CommonAPI.repeat(activity.id, user2)

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

	assert %{
	"reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
	"reblogged" => false,
	"favourited" => false,
	"bookmarked" => false
	} = json_response(conn_res, 200)

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

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
	"reblogged" => true,
	"favourited" => true,
	"bookmarked" => true
	} = json_response(conn_res, 200)

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

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

	test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} do
	activity = insert(:note_activity)

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

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

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 error when activity does not exist", %{conn: conn} do
	conn = post(conn, "/api/v1/statuses/foo/unreblog")

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "favoriting" do
	setup do: oauth_access(["write:favourites"])

	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)

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

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "favoriting twice will just return 200", %{conn: conn} do
	activity = insert(:note_activity)

	post(conn, "/api/v1/statuses/#{activity.id}/favourite")
	- assert post(conn, "/api/v1/statuses/#{activity.id}/favourite") \|> json_response(200)
	+
	+ assert post(conn, "/api/v1/statuses/#{activity.id}/favourite")
	+ \|> json_response(200)
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	- conn = post(conn, "/api/v1/statuses/1/favourite")
	+ conn =
	+ conn
	+ \|> post("/api/v1/statuses/1/favourite")

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "unfavoriting" do
	setup do: oauth_access(["write:favourites"])

	test "unfavorites a status and returns it", %{user: user, conn: conn} do
	activity = insert(:note_activity)

	- {:ok, _, _} = CommonAPI.favorite(activity.id, user)
	+ {:ok, _} = CommonAPI.favorite(user, activity.id)

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

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 404 error for a wrong id", %{conn: conn} do
	conn = post(conn, "/api/v1/statuses/1/unfavourite")

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end
	end

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

	setup %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	%{activity: activity}
	end

	setup do: clear_config([:instance, :max_pinned_statuses], 1)

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

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

	test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
	{:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})

	conn = post(conn, "/api/v1/statuses/#{dm.id}/pin")

	assert json_response(conn, 400) == %{"error" => "Could not pin"}
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)
	user = refresh_record(user)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

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

	test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
	conn = post(conn, "/api/v1/statuses/1/unpin")

	assert json_response(conn, 400) == %{"error" => "Could not unpin"}
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end
	end

	describe "cards" do
	setup do
	Config.put([:rich_media, :enabled], true)

	oauth_access(["read:statuses"])
	end

	test "returns rich-media card", %{conn: conn, user: user} do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})

	card_data = %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
	}
	}
	}

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

	assert response == card_data

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})

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

	assert response_two == card_data
	end

	test "replaces missing description with an empty string", %{conn: conn, user: user} do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})

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

	assert response == %{
	"type" => "link",
	"title" => "Pleroma",
	"description" => "",
	"image" => nil,
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"url" => "https://example.com/ogp-missing-data",
	"pleroma" => %{
	"opengraph" => %{
	"title" => "Pleroma",
	"type" => "website",
	"url" => "https://example.com/ogp-missing-data"
	}
	}
	}
	end
	end

	test "bookmarks" do
	%{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
	author = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(author, %{
	"status" => "heweoo?"
	})

	{:ok, activity2} =
	CommonAPI.post(author, %{
	"status" => "heweoo!"
	})

	response1 = post(conn, "/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response(response1, 200)["bookmarked"] == true

	response2 = post(conn, "/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response(response2, 200)["bookmarked"] == true

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

	assert [json_response(response2, 200), json_response(response1, 200)] ==
	json_response(bookmarks, 200)

	response1 = post(conn, "/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response(response1, 200)["bookmarked"] == false

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

	assert [json_response(response2, 200)] == json_response(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do: oauth_access(["write:mutes"])

	setup do
	post_user = insert(:user)
	{:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
	%{activity: activity}
	end

	test "mute conversation", %{conn: conn, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response(200)
	end

	test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

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

	assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	# \|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response(200)
	end
	end

	test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})

	# Reply to status from another user
	conn1 =
	conn
	\|> assign(:user, user2)
	\|> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)

	activity = Activity.get_by_id_with_object(id)

	assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id

	# Reblog from the third user
	conn2 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn2, 200)

	assert to_string(activity.id) == id

	# Getting third user status
	conn3 =
	conn
	\|> assign(:user, user3)
	\|> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
	\|> get("api/v1/timelines/home")

	[reblogged_activity] = json_response(conn3, 200)

	assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id

	replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
	assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
	end

	describe "GET /api/v1/statuses/:id/favourited_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have favorited the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	- {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
	+ {:ok, _} = CommonAPI.favorite(other_user, activity.id)

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

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been favorited yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have favorited the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

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

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

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	- {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
	+ {:ok, _} = CommonAPI.favorite(other_user, activity.id)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} wanna get some #cofe together?",
	"visibility" => "direct"
	})

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

	favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"

	build_conn()
	\|> get(favourited_by_url)
	\|> json_response(404)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))

	conn
	\|> assign(:token, nil)
	\|> get(favourited_by_url)
	\|> json_response(404)

	response =
	conn
	\|> get(favourited_by_url)
	\|> json_response(200)

	[%{"id" => id}] = response
	assert id == other_user.id
	end
	end

	describe "GET /api/v1/statuses/:id/reblogged_by" do
	setup do: oauth_access(["read:accounts"])

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

	%{activity: activity}
	end

	test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

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

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been reblogged yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, other_user)

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

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

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status privately", %{
	conn: conn,
	activity: activity
	} do
	other_user = insert(:user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user, %{"visibility" => "private"})

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

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end

	test "requires authentication for private posts", %{user: user} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} wanna get some #cofe together?",
	"visibility" => "direct"
	})

	build_conn()
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(404)

	response =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(200)

	assert [] == response
	end
	end

	test "context" do
	user = insert(:user)

	{:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
	{:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
	{:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
	{:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
	{:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})

	response =
	build_conn()
	\|> get("/api/v1/statuses/#{id3}/context")
	\|> json_response(:ok)

	assert %{
	"ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
	"descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
	} = response
	end

	test "returns the favorites of a user" do
	%{user: user, conn: conn} = oauth_access(["read:favourites"])
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

	- {:ok, _, _} = CommonAPI.favorite(activity.id, user)
	+ {:ok, _} = CommonAPI.favorite(user, activity.id)

	first_conn = get(conn, "/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	- {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
	+ {:ok, _} = CommonAPI.favorite(user, second_activity.id)

	last_like = status["id"]

	second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn = get(conn, "/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	test "expires_at is nil for another user" do
	%{conn: conn, user: user} = oauth_access(["read:statuses"])
	{:ok, activity} = CommonAPI.post(user, %{"status" => "foobar", "expires_in" => 1_000_000})

	expires_at =
	activity.id
	\|> ActivityExpiration.get_by_activity_id()
	\|> Map.get(:scheduled_at)
	\|> NaiveDateTime.to_iso8601()

	assert %{"pleroma" => %{"expires_at" => ^expires_at}} =
	conn \|> get("/api/v1/statuses/#{activity.id}") \|> json_response(:ok)

	%{conn: conn} = oauth_access(["read:statuses"])

	assert %{"pleroma" => %{"expires_at" => nil}} =
	conn \|> get("/api/v1/statuses/#{activity.id}") \|> json_response(:ok)
	end
	end
	diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
	index 8d00e3c21..4435f69ff 100644
	--- a/test/web/mastodon_api/views/account_view_test.exs
	+++ b/test/web/mastodon_api/views/account_view_test.exs
	@@ -1,554 +1,557 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	import Pleroma.Factory
	import Tesla.Mock

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

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	source_data: source_data,
	background: background_image,
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio:
	"<script src=\"invalid-html\"></script><span>valid html</span>. a<br>b<br/>c<br >d<br />f",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>. a<br/>b<br/>c<br/>d<br/>f",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	"static_url" => "/file.png",
	"url" => "/file.png",
	"shortcode" => "karjalanpiirakka",
	"visible_in_picker" => false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "valid html. a\nb\nc\nd\nf",
	sensitive: false,
	pleroma: %{
	actor_type: "Person",
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: "https://example.com/images/asuka_hospital.png",
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %Pleroma.User.NotificationSetting{}
	privacy = user.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	source_data: %{},
	actor_type: "Service",
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	actor_type: "Service",
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent a Funkwhale channel" do
	{:ok, user} =
	User.get_or_fetch_by_ap_id(
	"https://channels.tests.funkwhale.audio/federation/actors/compositions"
	)

	assert represented = AccountView.render("show.json", %{user: user})
	assert represented.acct == "compositions@channels.tests.funkwhale.audio"
	assert represented.url == "https://channels.tests.funkwhale.audio/channels/compositions"
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, is_admin: true)
	deactivated_user = insert(:user, deactivated: true)
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	describe "relationship" do
	defp test_relationship_rendering(user, other_user, expected_result) do
	opts = %{user: user, target: other_user, relationships: nil}
	assert expected_result == AccountView.render("relationship.json", opts)

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
	opts = Map.put(opts, :relationships, relationships_opt)
	assert expected_result == AccountView.render("relationship.json", opts)
	+
	+ assert [expected_result] ==
	+ AccountView.render("relationships.json", %{user: user, targets: [other_user]})
	end

	@blank_response %{
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationships} = User.mute(user, other_user, true)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, other_user)

	expected =
	Map.merge(
	@blank_response,
	%{
	following: true,
	followed_by: true,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	showing_reblogs: false,
	id: to_string(other_user.id)
	}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

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

	expected =
	Map.merge(
	@blank_response,
	%{following: false, blocking: true, blocked_by: true, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	expected =
	Map.merge(
	@blank_response,
	%{domain_blocking: true, blocking: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, locked: true)

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected =
	Map.merge(
	@blank_response,
	%{requested: true, following: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	follower_count: 0,
	note_count: 5,
	source_data: %{},
	actor_type: "Service",
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

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

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 1,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	actor_type: "Service",
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: false,
	subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	},
	skip_thread_containment: false
	}
	}

	assert expected ==
	AccountView.render("show.json", %{user: refresh_record(user), for: other_user})
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, pleroma_settings_store: %{fe: "test"})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "doesn't sanitize display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user})
	assert result.display_name == "<marquee> username </marquee>"
	end

	test "never display nil user follow counts" do
	user = insert(:user, following_count: 0, follower_count: 0)
	result = AccountView.render("show.json", %{user: user})

	assert result.following_count == 0
	assert result.followers_count == 0
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	user =
	insert(:user, %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows unread_conversation_count only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

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

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	:unread_conversation_count
	] == nil

	assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	:unread_conversation_count
	] == 1
	end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	{:ok, user} = User.update_and_set_cache(user, %{locked: false})

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end
	end
	diff --git a/test/web/mastodon_api/views/notification_view_test.exs b/test/web/mastodon_api/views/notification_view_test.exs
	index 81eefd735..c3ec9dfec 100644
	--- a/test/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/web/mastodon_api/views/notification_view_test.exs
	@@ -1,179 +1,179 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	import Pleroma.Factory

	defp test_notifications_rendering(notifications, user, expected_result) do
	result = NotificationView.render("index.json", %{notifications: notifications, for: user})

	assert expected_result == result

	result =
	NotificationView.render("index.json", %{
	notifications: notifications,
	for: user,
	relationships: nil
	})

	assert expected_result == result
	end

	test "Mention notification" do
	user = insert(:user)
	mentioned_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{mentioned_user.nickname}"})
	{:ok, [notification]} = Notification.create_notifications(activity)
	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "mention",
	account: AccountView.render("show.json", %{user: user, for: mentioned_user}),
	status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], mentioned_user, [expected])
	end

	test "Favourite notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	- {:ok, favorite_activity, _object} = CommonAPI.favorite(create_activity.id, another_user)
	+ {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Reblog notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, reblog_activity, _object} = CommonAPI.repeat(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(reblog_activity)
	reblog_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "reblog",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Follow notification" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, follower, followed, _activity} = CommonAPI.follow(follower, followed)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "follow",
	account: AccountView.render("show.json", %{user: follower, for: followed}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], followed, [expected])

	User.perform(:delete, follower)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	test_notifications_rendering([notification], followed, [])
	end

	@tag capture_log: true
	test "Move notification" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	follower = insert(:user)

	old_user_url = old_user.ap_id

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", old_user.nickname)
	\|> Jason.encode!()

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

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	old_user = refresh_record(old_user)
	new_user = refresh_record(new_user)

	[notification] = Notification.for_user(follower)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "move",
	account: AccountView.render("show.json", %{user: old_user, for: follower}),
	target: AccountView.render("show.json", %{user: new_user, for: follower}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], follower, [expected])
	end

	test "EmojiReact notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
	{:ok, _activity, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "pleroma:emoji_reaction",
	emoji: "☕",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end
	end
	diff --git a/test/web/node_info_test.exs b/test/web/node_info_test.exs
	index 43f322606..9bcc07b37 100644
	--- a/test/web/node_info_test.exs
	+++ b/test/web/node_info_test.exs
	@@ -1,181 +1,207 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.NodeInfoTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	+ alias Pleroma.Config
	+
	setup do: clear_config([:mrf_simple])
	setup do: clear_config(:instance)

	test "GET /.well-known/nodeinfo", %{conn: conn} do
	links =
	conn
	\|> get("/.well-known/nodeinfo")
	\|> json_response(200)
	\|> Map.fetch!("links")

	Enum.each(links, fn link ->
	href = Map.fetch!(link, "href")

	conn
	\|> get(href)
	\|> json_response(200)
	end)
	end

	test "nodeinfo shows staff accounts", %{conn: conn} do
	moderator = insert(:user, local: true, is_moderator: true)
	admin = insert(:user, local: true, is_admin: true)

	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)

	assert moderator.ap_id in result["metadata"]["staffAccounts"]
	assert admin.ap_id in result["metadata"]["staffAccounts"]
	end

	test "nodeinfo shows restricted nicknames", %{conn: conn} do
	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)

	- assert Pleroma.Config.get([Pleroma.User, :restricted_nicknames]) ==
	+ assert Config.get([Pleroma.User, :restricted_nicknames]) ==
	result["metadata"]["restrictedNicknames"]
	end

	test "returns software.repository field in nodeinfo 2.1", %{conn: conn} do
	conn
	\|> get("/.well-known/nodeinfo")
	\|> json_response(200)

	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)
	assert Pleroma.Application.repository() == result["software"]["repository"]
	end

	test "returns fieldsLimits field", %{conn: conn} do
	- Pleroma.Config.put([:instance, :max_account_fields], 10)
	- Pleroma.Config.put([:instance, :max_remote_account_fields], 15)
	- Pleroma.Config.put([:instance, :account_field_name_length], 255)
	- Pleroma.Config.put([:instance, :account_field_value_length], 2048)
	+ Config.put([:instance, :max_account_fields], 10)
	+ Config.put([:instance, :max_remote_account_fields], 15)
	+ Config.put([:instance, :account_field_name_length], 255)
	+ Config.put([:instance, :account_field_value_length], 2048)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["fieldsLimits"]["maxFields"] == 10
	assert response["metadata"]["fieldsLimits"]["maxRemoteFields"] == 15
	assert response["metadata"]["fieldsLimits"]["nameLength"] == 255
	assert response["metadata"]["fieldsLimits"]["valueLength"] == 2048
	end

	test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
	- option = Pleroma.Config.get([:instance, :safe_dm_mentions])
	- Pleroma.Config.put([:instance, :safe_dm_mentions], true)
	+ option = Config.get([:instance, :safe_dm_mentions])
	+ Config.put([:instance, :safe_dm_mentions], true)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert "safe_dm_mentions" in response["metadata"]["features"]

	- Pleroma.Config.put([:instance, :safe_dm_mentions], false)
	+ Config.put([:instance, :safe_dm_mentions], false)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	refute "safe_dm_mentions" in response["metadata"]["features"]

	- Pleroma.Config.put([:instance, :safe_dm_mentions], option)
	+ Config.put([:instance, :safe_dm_mentions], option)
	end

	describe "`metadata/federation/enabled`" do
	setup do: clear_config([:instance, :federating])

	test "it shows if federation is enabled/disabled", %{conn: conn} do
	- Pleroma.Config.put([:instance, :federating], true)
	+ Config.put([:instance, :federating], true)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["enabled"] == true

	- Pleroma.Config.put([:instance, :federating], false)
	+ Config.put([:instance, :federating], false)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["enabled"] == false
	end
	end

	+ test "it shows default features flags", %{conn: conn} do
	+ response =
	+ conn
	+ \|> get("/nodeinfo/2.1.json")
	+ \|> json_response(:ok)
	+
	+ default_features = [
	+ "pleroma_api",
	+ "mastodon_api",
	+ "mastodon_api_streaming",
	+ "polls",
	+ "pleroma_explicit_addressing",
	+ "shareable_emoji_packs",
	+ "multifetch",
	+ "pleroma_emoji_reactions",
	+ "pleroma:api/v1/notifications:include_types_filter"
	+ ]
	+
	+ assert MapSet.subset?(
	+ MapSet.new(default_features),
	+ MapSet.new(response["metadata"]["features"])
	+ )
	+ end
	+
	test "it shows MRF transparency data if enabled", %{conn: conn} do
	- config = Pleroma.Config.get([:instance, :rewrite_policy])
	- Pleroma.Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
	+ config = Config.get([:instance, :rewrite_policy])
	+ Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])

	- option = Pleroma.Config.get([:instance, :mrf_transparency])
	- Pleroma.Config.put([:instance, :mrf_transparency], true)
	+ option = Config.get([:instance, :mrf_transparency])
	+ Config.put([:instance, :mrf_transparency], true)

	simple_config = %{"reject" => ["example.com"]}
	- Pleroma.Config.put(:mrf_simple, simple_config)
	+ Config.put(:mrf_simple, simple_config)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["mrf_simple"] == simple_config

	- Pleroma.Config.put([:instance, :rewrite_policy], config)
	- Pleroma.Config.put([:instance, :mrf_transparency], option)
	- Pleroma.Config.put(:mrf_simple, %{})
	+ Config.put([:instance, :rewrite_policy], config)
	+ Config.put([:instance, :mrf_transparency], option)
	+ Config.put(:mrf_simple, %{})
	end

	test "it performs exclusions from MRF transparency data if configured", %{conn: conn} do
	- config = Pleroma.Config.get([:instance, :rewrite_policy])
	- Pleroma.Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
	+ config = Config.get([:instance, :rewrite_policy])
	+ Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])

	- option = Pleroma.Config.get([:instance, :mrf_transparency])
	- Pleroma.Config.put([:instance, :mrf_transparency], true)
	+ option = Config.get([:instance, :mrf_transparency])
	+ Config.put([:instance, :mrf_transparency], true)

	- exclusions = Pleroma.Config.get([:instance, :mrf_transparency_exclusions])
	- Pleroma.Config.put([:instance, :mrf_transparency_exclusions], ["other.site"])
	+ exclusions = Config.get([:instance, :mrf_transparency_exclusions])
	+ Config.put([:instance, :mrf_transparency_exclusions], ["other.site"])

	simple_config = %{"reject" => ["example.com", "other.site"]}
	expected_config = %{"reject" => ["example.com"]}

	- Pleroma.Config.put(:mrf_simple, simple_config)
	+ Config.put(:mrf_simple, simple_config)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["mrf_simple"] == expected_config
	assert response["metadata"]["federation"]["exclusions"] == true

	- Pleroma.Config.put([:instance, :rewrite_policy], config)
	- Pleroma.Config.put([:instance, :mrf_transparency], option)
	- Pleroma.Config.put([:instance, :mrf_transparency_exclusions], exclusions)
	- Pleroma.Config.put(:mrf_simple, %{})
	+ Config.put([:instance, :rewrite_policy], config)
	+ Config.put([:instance, :mrf_transparency], option)
	+ Config.put([:instance, :mrf_transparency_exclusions], exclusions)
	+ Config.put(:mrf_simple, %{})
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index 6787b414b..bb349cb19 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,293 +1,293 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

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

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

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /objects/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn = get(conn, url)
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on non-existing objects", %{conn: conn} do
	conn
	\|> get("/objects/123")
	\|> response(404)
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /activities/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn = get(conn, "/activities/#{uuid}")
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> get("/activities/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	conn
	\|> get("/activities/123")
	\|> response(404)
	end
	end

	describe "GET notice/2" do
	test "redirects to a proper object URL when json requested and the object is local", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	expected_redirect_url = Object.normalize(note_activity).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "returns a 404 on remote notice when json requested", %{conn: conn} do
	note_activity = insert(:note_activity, local: false)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> response(404)
	end

	test "500s when actor not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> get("/notice/#{note_activity.id}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "render html for redirect for html format", %{conn: conn} do
	note_activity = insert(:note_activity)

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)

	assert resp =~
	"<meta content=\"#{Pleroma.Web.base_url()}/notice/#{note_activity.id}\" property=\"og:url\">"

	user = insert(:user)

	- {:ok, like_activity, _} = CommonAPI.favorite(note_activity.id, user)
	+ {:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert like_activity.data["type"] == "Like"

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{like_activity.id}")
	\|> response(200)

	assert resp =~ "<!--server-generated-meta-->"
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a non-existing notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)
	note_activity = insert(:note_activity)

	conn = put_req_header(conn, "accept", "text/html")

	ensure_federating_or_authenticated(conn, "/notice/#{note_activity.id}", user)
	end
	end

	describe "GET /notice/:id/embed_player" do
	setup do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

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

	%{note_activity: note_activity}
	end

	test "renders embed player", %{conn: conn, note_activity: note_activity} do
	conn = get(conn, "/notice/#{note_activity.id}/embed_player")

	assert Plug.Conn.get_resp_header(conn, "x-frame-options") == ["ALLOW"]

	assert Plug.Conn.get_resp_header(
	conn,
	"content-security-policy"
	) == [
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	]

	assert response(conn, 200) =~
	"<video controls loop><source src=\"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4\" type=\"video/mp4\">Your browser does not support video/mp4 playback.</video>"
	end

	test "404s when activity isn't create", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"type" => "Like"})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when activity is direct message", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"directMessage" => true})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment is empty", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)
	object_data = Map.put(object.data, "attachment", [])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment isn't audio or video", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" => "https://peertube.moe/static/webseed/480.jpg",
	"mediaType" => "image/jpg",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn,
	note_activity: note_activity
	} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "text/html")

	ensure_federating_or_authenticated(conn, "/notice/#{note_activity.id}/embed_player", user)
	end
	end
	end
	diff --git a/test/web/pleroma_api/controllers/account_controller_test.exs b/test/web/pleroma_api/controllers/account_controller_test.exs
	index 2aa87ac30..ae5334015 100644
	--- a/test/web/pleroma_api/controllers/account_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/account_controller_test.exs
	@@ -1,336 +1,336 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Config
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Swoosh.TestAssertions

	@image "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"

	describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
	setup do
	{:ok, user} =
	insert(:user)
	\|> User.confirmation_changeset(need_confirmation: true)
	\|> User.update_and_set_cache()

	assert user.confirmation_pending

	[user: user]
	end

	setup do: clear_config([:instance, :account_activation_required], true)

	test "resend account confirmation email", %{conn: conn, user: user} do
	conn
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
	\|> json_response(:no_content)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

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

	describe "PATCH /api/v1/pleroma/accounts/update_avatar" do
	setup do: oauth_access(["write:accounts"])

	test "user avatar can be set", %{user: user, conn: conn} do
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn = patch(conn, "/api/v1/pleroma/accounts/update_avatar", %{img: avatar_image})

	user = refresh_record(user)

	assert %{
	"name" => _,
	"type" => _,
	"url" => [
	%{
	"href" => _,
	"mediaType" => _,
	"type" => _
	}
	]
	} = user.avatar

	assert %{"url" => _} = json_response(conn, 200)
	end

	test "user avatar can be reset", %{user: user, conn: conn} do
	conn = patch(conn, "/api/v1/pleroma/accounts/update_avatar", %{img: ""})

	user = User.get_cached_by_id(user.id)

	assert user.avatar == nil

	assert %{"url" => nil} = json_response(conn, 200)
	end
	end

	describe "PATCH /api/v1/pleroma/accounts/update_banner" do
	setup do: oauth_access(["write:accounts"])

	test "can set profile banner", %{user: user, conn: conn} do
	conn = patch(conn, "/api/v1/pleroma/accounts/update_banner", %{"banner" => @image})

	user = refresh_record(user)
	assert user.banner["type"] == "Image"

	assert %{"url" => _} = json_response(conn, 200)
	end

	test "can reset profile banner", %{user: user, conn: conn} do
	conn = patch(conn, "/api/v1/pleroma/accounts/update_banner", %{"banner" => ""})

	user = refresh_record(user)
	assert user.banner == %{}

	assert %{"url" => nil} = json_response(conn, 200)
	end
	end

	describe "PATCH /api/v1/pleroma/accounts/update_background" do
	setup do: oauth_access(["write:accounts"])

	test "background image can be set", %{user: user, conn: conn} do
	conn = patch(conn, "/api/v1/pleroma/accounts/update_background", %{"img" => @image})

	user = refresh_record(user)
	assert user.background["type"] == "Image"
	assert %{"url" => _} = json_response(conn, 200)
	end

	test "background image can be reset", %{user: user, conn: conn} do
	conn = patch(conn, "/api/v1/pleroma/accounts/update_background", %{"img" => ""})

	user = refresh_record(user)
	assert user.background == %{}
	assert %{"url" => nil} = json_response(conn, 200)
	end
	end

	describe "getting favorites timeline of specified user" do
	setup do
	[current_user, user] = insert_pair(:user, hide_favorites: false)
	%{user: current_user, conn: conn} = oauth_access(["read:favourites"], user: current_user)
	[current_user: current_user, user: user, conn: conn]
	end

	test "returns list of statuses favorited by specified user", %{
	conn: conn,
	user: user
	} do
	[activity \| _] = insert_pair(:note_activity)
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	[like] = response

	assert length(response) == 1
	assert like["id"] == activity.id
	end

	test "does not return favorites for specified user_id when user is not logged in", %{
	user: user
	} do
	activity = insert(:note_activity)
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)

	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(403)
	end

	test "returns favorited DM only when user is logged in and he is one of recipients", %{
	current_user: current_user,
	user: user
	} do
	{:ok, direct} =
	CommonAPI.post(current_user, %{
	"status" => "Hi @#{user.nickname}!",
	"visibility" => "direct"
	})

	- CommonAPI.favorite(direct.id, user)
	+ CommonAPI.favorite(user, direct.id)

	for u <- [user, current_user] do
	response =
	build_conn()
	\|> assign(:user, u)
	\|> assign(:token, insert(:oauth_token, user: u, scopes: ["read:favourites"]))
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert length(response) == 1
	end

	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(403)
	end

	test "does not return others' favorited DM when user is not one of recipients", %{
	conn: conn,
	user: user
	} do
	user_two = insert(:user)

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

	- CommonAPI.favorite(direct.id, user)
	+ CommonAPI.favorite(user, direct.id)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "paginates favorites using since_id and max_id", %{
	conn: conn,
	user: user
	} do
	activities = insert_list(10, :note_activity)

	Enum.each(activities, fn activity ->
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)
	end)

	third_activity = Enum.at(activities, 2)
	seventh_activity = Enum.at(activities, 6)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
	since_id: third_activity.id,
	max_id: seventh_activity.id
	})
	\|> json_response(:ok)

	assert length(response) == 3
	refute third_activity in response
	refute seventh_activity in response
	end

	test "limits favorites using limit parameter", %{
	conn: conn,
	user: user
	} do
	7
	\|> insert_list(:note_activity)
	\|> Enum.each(fn activity ->
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)
	end)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
	\|> json_response(:ok)

	assert length(response) == 3
	end

	test "returns empty response when user does not have any favorited statuses", %{
	conn: conn,
	user: user
	} do
	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 403 error when user has hidden own favorites", %{conn: conn} do
	user = insert(:user, hide_favorites: true)
	activity = insert(:note_activity)
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)

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

	assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
	end

	test "hides favorites for new users by default", %{conn: conn} do
	user = insert(:user)
	activity = insert(:note_activity)
	- CommonAPI.favorite(activity.id, user)
	+ CommonAPI.favorite(user, activity.id)

	assert user.hide_favorites
	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
	end
	end

	describe "subscribing / unsubscribing" do
	test "subscribing / unsubscribing to a user" do
	%{user: user, conn: conn} = oauth_access(["follow"])
	subscription_target = insert(:user)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")

	assert %{"id" => _id, "subscribing" => true} = json_response(ret_conn, 200)

	conn = post(conn, "/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")

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

	describe "subscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["write:follows"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/subscribe")

	assert %{"error" => "Record not found"} = json_response(conn, 404)
	end
	end

	describe "unsubscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["follow"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/unsubscribe")

	assert %{"error" => "Record not found"} = json_response(conn, 404)
	end
	end
	end
	diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
	index 9f931c941..9121d90e7 100644
	--- a/test/web/push/impl_test.exs
	+++ b/test/web/push/impl_test.exs
	@@ -1,240 +1,240 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	use Pleroma.DataCase

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "<Lorem ipsum dolor sit amet."})

	notif =
	insert(:notification,
	user: user,
	activity: activity
	)

	assert Impl.perform(notif) == [:ok, :ok]
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	assert Impl.perform(%{}) == :error
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	@tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subscription if result send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "deletes subscription when token has been deleted" do
	subscription = insert(:push_subscription)

	Pleroma.Repo.delete(subscription.token)

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders title and body for create activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	object = Object.normalize(activity)

	assert Impl.format_body(
	%{
	activity: activity
	},
	user,
	object
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: activity}) ==
	"New Mention"
	end

	test "renders title and body for follow activity" do
	user = insert(:user, nickname: "Bob")
	other_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, other_user)
	object = Object.normalize(activity, false)

	assert Impl.format_body(%{activity: activity}, user, object) == "@Bob has followed you"

	assert Impl.format_title(%{activity: activity}) ==
	"New Follower"
	end

	test "renders title and body for announce activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: announce_activity}, user, object) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: announce_activity}) ==
	"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(activity.id, user)
	+ {:ok, activity} = CommonAPI.favorite(user, activity.id)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity}, user, object) == "@Bob has favorited your post"

	assert Impl.format_title(%{activity: activity}) ==
	"New Favorite"
	end

	test "renders title for create activity with direct visibility" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	"visibility" => "direct",
	"status" => "This is just between you and me, pal"
	})

	assert Impl.format_title(%{activity: activity}) ==
	"New Direct Message"
	end

	describe "build_content/3" do
	test "returns info content for direct message with enabled privacy option" do
	user = insert(:user, nickname: "Bob")
	user2 = insert(:user, nickname: "Rob", notification_settings: %{privacy_option: true})

	{:ok, activity} =
	CommonAPI.post(user, %{
	"visibility" => "direct",
	"status" => "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "@Bob",
	title: "New Direct Message"
	}
	end

	test "returns regular content for direct message with disabled privacy option" do
	user = insert(:user, nickname: "Bob")
	user2 = insert(:user, nickname: "Rob", notification_settings: %{privacy_option: false})

	{:ok, activity} =
	CommonAPI.post(user, %{
	"visibility" => "direct",
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	title: "New Direct Message"
	}
	end
	end
	end
	diff --git a/test/web/streamer/streamer_test.exs b/test/web/streamer/streamer_test.exs
	index 5b928629b..b3fe22920 100644
	--- a/test/web/streamer/streamer_test.exs
	+++ b/test/web/streamer/streamer_test.exs
	@@ -1,628 +1,628 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StreamerTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Conversation.Participation
	alias Pleroma.List
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.Streamer.StreamerSocket
	alias Pleroma.Web.Streamer.Worker

	@moduletag needs_streamer: true, capture_log: true

	@streamer_timeout 150
	@streamer_start_wait 10
	setup do: clear_config([:instance, :skip_thread_containment])

	describe "user streams" do
	setup do
	user = insert(:user)
	notify = insert(:notification, user: user, activity: build(:note_activity))
	{:ok, %{user: user, notify: notify}}
	end

	test "it sends notify to in the 'user' stream", %{user: user, notify: notify} do
	task =
	Task.async(fn ->
	assert_receive {:text, _}, @streamer_timeout
	end)

	Streamer.add_socket(
	"user",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	Streamer.stream("user", notify)
	Task.await(task)
	end

	test "it sends notify to in the 'user:notification' stream", %{user: user, notify: notify} do
	task =
	Task.async(fn ->
	assert_receive {:text, _}, @streamer_timeout
	end)

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	Streamer.stream("user:notification", notify)
	Task.await(task)
	end

	test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
	user: user
	} do
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

	- {:ok, activity} = CommonAPI.post(user, %{"status" => ":("})
	- {:ok, notif, _} = CommonAPI.favorite(activity.id, blocked)
	-
	task = Task.async(fn -> refute_receive {:text, _}, @streamer_timeout end)

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	+ {:ok, activity} = CommonAPI.post(user, %{"status" => ":("})
	+ {:ok, notif} = CommonAPI.favorite(blocked, activity.id)
	+
	Streamer.stream("user:notification", notif)
	Task.await(task)
	end

	test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
	user: user
	} do
	user2 = insert(:user)

	- {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
	- {:ok, activity} = CommonAPI.add_mute(user, activity)
	- {:ok, notif, _} = CommonAPI.favorite(activity.id, user2)
	-
	task = Task.async(fn -> refute_receive {:text, _}, @streamer_timeout end)

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
	+ {:ok, activity} = CommonAPI.add_mute(user, activity)
	+ {:ok, notif} = CommonAPI.favorite(user2, activity.id)
	+
	Streamer.stream("user:notification", notif)
	Task.await(task)
	end

	test "it doesn't send notify to the 'user:notification' stream' when a domain is blocked", %{
	user: user
	} do
	user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})

	- {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	- {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
	- {:ok, notif, _} = CommonAPI.favorite(activity.id, user2)
	-
	task = Task.async(fn -> refute_receive {:text, _}, @streamer_timeout end)

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	+ {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
	+ {:ok, notif} = CommonAPI.favorite(user2, activity.id)
	+
	Streamer.stream("user:notification", notif)
	Task.await(task)
	end

	test "it sends follow activities to the 'user:notification' stream", %{
	user: user
	} do
	user_url = user.ap_id

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", user.nickname)
	\|> Jason.encode!()

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

	user2 = insert(:user)
	task = Task.async(fn -> assert_receive {:text, _}, @streamer_timeout end)

	Process.sleep(@streamer_start_wait)

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	{:ok, _follower, _followed, _activity} = CommonAPI.follow(user2, user)

	# We don't directly pipe the notification to the streamer as it's already
	# generated as a side effect of CommonAPI.follow().
	Task.await(task)
	end
	end

	test "it sends to public" do
	user = insert(:user)
	other_user = insert(:user)

	task =
	Task.async(fn ->
	assert_receive {:text, _}, @streamer_timeout
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user
	}

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"})

	topics = %{
	"public" => [fake_socket]
	}

	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)

	task =
	Task.async(fn ->
	expected_event =
	%{
	"event" => "delete",
	"payload" => activity.id
	}
	\|> Jason.encode!()

	assert_receive {:text, received_event}, @streamer_timeout
	assert received_event == expected_event
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user
	}

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

	topics = %{
	"public" => [fake_socket]
	}

	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)
	end

	describe "thread_containment" do
	test "it doesn't send to user if recipients invalid and thread containment is enabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], false)
	author = insert(:user)
	user = insert(:user)
	User.follow(user, author, "accept")

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	task = Task.async(fn -> refute_receive {:text, _}, 1_000 end)
	fake_socket = %StreamerSocket{transport_pid: task.pid, user: user}
	topics = %{"public" => [fake_socket]}
	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)
	end

	test "it sends message if recipients invalid and thread containment is disabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], true)
	author = insert(:user)
	user = insert(:user)
	User.follow(user, author, "accept")

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	task = Task.async(fn -> assert_receive {:text, _}, 1_000 end)
	fake_socket = %StreamerSocket{transport_pid: task.pid, user: user}
	topics = %{"public" => [fake_socket]}
	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)
	end

	test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
	Pleroma.Config.put([:instance, :skip_thread_containment], false)
	author = insert(:user)
	user = insert(:user, skip_thread_containment: true)
	User.follow(user, author, "accept")

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["TEST-FFF"]}
	)
	)

	task = Task.async(fn -> assert_receive {:text, _}, 1_000 end)
	fake_socket = %StreamerSocket{transport_pid: task.pid, user: user}
	topics = %{"public" => [fake_socket]}
	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)
	end
	end

	describe "blocks" do
	test "it doesn't send messages involving blocked users" do
	user = insert(:user)
	blocked_user = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked_user)

	{:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"})

	task =
	Task.async(fn ->
	refute_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user
	}

	topics = %{
	"public" => [fake_socket]
	}

	Worker.push_to_socket(topics, "public", activity)

	Task.await(task)
	end

	test "it doesn't send messages transitively involving blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	task =
	Task.async(fn ->
	refute_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: blocker
	}

	topics = %{
	"public" => [fake_socket]
	}

	{:ok, _user_relationship} = User.block(blocker, blockee)

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

	Worker.push_to_socket(topics, "public", activity_one)

	{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	Worker.push_to_socket(topics, "public", activity_two)

	{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})

	Worker.push_to_socket(topics, "public", activity_three)

	Task.await(task)
	end
	end

	test "it doesn't send unwanted DMs to list" do
	user_a = insert(:user)
	user_b = insert(:user)
	user_c = insert(:user)

	{:ok, user_a} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	{:ok, activity} =
	CommonAPI.post(user_b, %{
	"status" => "@#{user_c.nickname} Test",
	"visibility" => "direct"
	})

	task =
	Task.async(fn ->
	refute_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user_a
	}

	topics = %{
	"list:#{list.id}" => [fake_socket]
	}

	Worker.handle_call({:stream, "list", activity}, self(), topics)

	Task.await(task)
	end

	test "it doesn't send unwanted private posts to list" do
	user_a = insert(:user)
	user_b = insert(:user)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	{:ok, activity} =
	CommonAPI.post(user_b, %{
	"status" => "Test",
	"visibility" => "private"
	})

	task =
	Task.async(fn ->
	refute_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user_a
	}

	topics = %{
	"list:#{list.id}" => [fake_socket]
	}

	Worker.handle_call({:stream, "list", activity}, self(), topics)

	Task.await(task)
	end

	test "it sends wanted private posts to list" do
	user_a = insert(:user)
	user_b = insert(:user)

	{:ok, user_a} = User.follow(user_a, user_b)

	{:ok, list} = List.create("Test", user_a)
	{:ok, list} = List.follow(list, user_b)

	{:ok, activity} =
	CommonAPI.post(user_b, %{
	"status" => "Test",
	"visibility" => "private"
	})

	task =
	Task.async(fn ->
	assert_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user_a
	}

	Streamer.add_socket(
	"list:#{list.id}",
	fake_socket
	)

	Worker.handle_call({:stream, "list", activity}, self(), %{})

	Task.await(task)
	end

	test "it doesn't send muted reblogs" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.hide_reblogs(user1, user2)

	{:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"})
	{:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2)

	task =
	Task.async(fn ->
	refute_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user1
	}

	topics = %{
	"public" => [fake_socket]
	}

	Worker.push_to_socket(topics, "public", announce_activity)

	Task.await(task)
	end

	test "it does send non-reblog notification for reblog-muted actors" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.hide_reblogs(user1, user2)

	{:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"})
	- {:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, user2)
	+ {:ok, favorite_activity} = CommonAPI.favorite(user2, create_activity.id)

	task =
	Task.async(fn ->
	assert_receive {:text, _}, 1_000
	end)

	fake_socket = %StreamerSocket{
	transport_pid: task.pid,
	user: user1
	}

	topics = %{
	"public" => [fake_socket]
	}

	Worker.push_to_socket(topics, "public", favorite_activity)

	Task.await(task)
	end

	test "it doesn't send posts from muted threads" do
	user = insert(:user)
	user2 = insert(:user)
	{:ok, user2, user, _activity} = CommonAPI.follow(user2, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})

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

	task = Task.async(fn -> refute_receive {:text, _}, @streamer_timeout end)

	Streamer.add_socket(
	"user",
	%{transport_pid: task.pid, assigns: %{user: user2}}
	)

	Streamer.stream("user", activity)
	Task.await(task)
	end

	describe "direct streams" do
	setup do
	:ok
	end

	test "it sends conversation update to the 'direct' stream", %{} do
	user = insert(:user)
	another_user = insert(:user)

	task =
	Task.async(fn ->
	assert_receive {:text, received_event}, @streamer_timeout

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	[participation] = Participation.for_user(user)
	assert last_status["pleroma"]["direct_conversation_id"] == participation.id
	end)

	Streamer.add_socket(
	"direct",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

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

	Task.await(task)
	end

	test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted" do
	user = insert(:user)
	another_user = insert(:user)

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

	task =
	Task.async(fn ->
	assert_receive {:text, received_event}, @streamer_timeout
	assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)

	refute_receive {:text, _}, @streamer_timeout
	end)

	Process.sleep(@streamer_start_wait)

	Streamer.add_socket(
	"direct",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	{:ok, _} = CommonAPI.delete(create_activity.id, another_user)

	Task.await(task)
	end

	test "it sends conversation update to the 'direct' stream when a message is deleted" do
	user = insert(:user)
	another_user = insert(:user)

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

	{:ok, create_activity2} =
	CommonAPI.post(another_user, %{
	"status" => "hi @#{user.nickname}",
	"in_reply_to_status_id" => create_activity.id,
	"visibility" => "direct"
	})

	task =
	Task.async(fn ->
	assert_receive {:text, received_event}, @streamer_timeout
	assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)

	assert_receive {:text, received_event}, @streamer_timeout

	assert %{"event" => "conversation", "payload" => received_payload} =
	Jason.decode!(received_event)

	assert %{"last_status" => last_status} = Jason.decode!(received_payload)
	assert last_status["id"] == to_string(create_activity.id)
	end)

	Process.sleep(@streamer_start_wait)

	Streamer.add_socket(
	"direct",
	%{transport_pid: task.pid, assigns: %{user: user}}
	)

	{:ok, _} = CommonAPI.delete(create_activity2.id, another_user)

	Task.await(task)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 12:17 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723162
Default Alt Text: (702 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions