T6: the Mastodon API over HTTP

88 integration tests drive the Mastodon client API through the whole server
(PrivaPubHost), with remote actors on an in-process Peer and deliveries read
from the job queue. Helpers live in Support/Host/MastodonHelpers.cs.

Coverage:
- Accounts: verify_credentials (no root id or login name); update_credentials
  with indexed and array fields_attributes (form and JSON), source[*],
  quote_policy, locked/bot, avatar and header uploads resized and stripped of
  EXIF and XMP; lookup (local, @domain, remote; a circle, the instance actor
  and a circle's id answer 404); search with and without resolve (only a
  signed-in persona resolves, the Peer is untouched otherwise), by post and
  actor address, hashtags, undiscoverable personas; account statuses with
  pinned, exclude_replies, exclude_reblogs, only_media, tagged and Link paging
  both ways; followers-only posts for followers (local and remote authors);
  community accounts; followers/following only to their owner; follow (open,
  locked, remote Follow delivery), unfollow and Undo; follow requests from
  local and remote followers answered with the original Follow;
  remove_from_followers; blocks with Reject and Block/Undo deliveries; mutes
  with duration and the notifications choice, never federated; domain blocks;
  relationships with junk ids; a banned login's tokens; reports forwarded as a
  Flag from the instance actor only; account stub routes.
- Statuses: each visibility's to/cc as delivered; CW as summary; replies to
  local and remote posts (mention, inReplyTo, the author's inbox); polls and
  votes (local, and remote votes only to the author without published); media
  attached only by its owner; quotes, the quotes list and revocation; edit
  history, source and the Update delivery; delete for redraft, the 410
  Tombstone and the Delete delivery; favourite/reblog counts with Like,
  Announce and their Undos; favourited_by, reblogged_by; bookmarks; pins;
  interaction_policy matching canQuote in the note and in the Update;
  strangers get 404 for followers-only and direct posts; a located post is
  unreachable by id for anyone else on every route; statuses?id[];
  Idempotency-Key; scopes; deleting a reblog.
- Timelines: home paging with max_id, since_id and min_id; public local and
  remote; tag (anonymous); list stub; favourites; conversations and read;
  markers; notifications with types[], exclude_types[], account_id, paging,
  get, dismiss, clear and unread_count.
- Instance: v1 and v2 (4.2.0 (compatible; PrivaPub)), peers, activity, rules,
  extended_description, apps and every stub route.
- Media: v1 and v2 uploads, owner-only GET and PUT, 422 for unsupported or
  unreadable files, video and audio made with ffmpeg lavfi sources and checked
  with ffprobe; every remote media address goes through the proxy; the proxy
  refuses unsigned URLs, streams ranges as 206 without caching, caches whole
  downloads and serves them with ranges, and streams anything over
  Media:MaxProxiedBytes (a SmallProxyHost) without caching.
- Provenance of local, delivered (signature) and fetched (instance actor,
  no signature, the trigger as activity) posts, visibility of provenance,
  instance descriptions; reading any of them makes no outbound request.
  Pleroma reactions with EmojiReact and Undo deliveries, and local reaction
  notifications.

Bugs fixed:
- remove_from_followers deleted the Follower row but never told a remote
  follower. It now sends Reject{Follow} with the stored Follow id, through
  RelationshipService.RemoveFollower, which Block now shares.
- VisibilityPolicy.CanSee refused followers-only posts to accepted followers,
  so a post in their home timeline answered 404 to GET, context, favourite and
  reply. Followers of the author (local or remote) may now see them.
- Account statuses of a remote account hid followers-only posts from
  personas that follow it.
- exclude_replies dropped the author's own threads; like Mastodon it now
  drops only replies to other accounts.
- A community account's statuses were always empty: they are now the posts
  addressed to the community.
- Pinning someone else's visible post answered 404; it answers 422 like
  Mastodon.
- GET /api/v1/notifications/:id answered 200 with null when the notification's
  post was gone; it answers 404.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01ELjqpznMFMNrJoJUj6K5p2

PrivaPub.Tests/Http/MastodonInstanceTests.cs

@@ -0,0 +1,133 @@
+using PrivaPub.Api.Mastodon.Controllers;
+using PrivaPub.Tests.Support;
+using PrivaPub.Tests.Support.Host;
+
+using System.Net;
+
+namespace PrivaPub.Tests.Http
+{
+	[Trait("Category", "Integration")]
+	public sealed class MastodonInstanceTests : IAsyncLifetime
+	{
+		PrivaPubHost _host;
+
+		public async ValueTask InitializeAsync()
+		{
+			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
+			_host = await PrivaPubHost.Shared();
+		}
+
+		public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+
+		[Fact]
+		public async Task Both_instance_documents_advertise_mastodon_4_2_and_the_domain()
+		{
+			var anonymous = _host.Client();
+
+			var v1 = (await anonymous.Get("/api/v1/instance")).Ok();
+			Assert.Equal("4.2.0 (compatible; PrivaPub)", v1.Body.Text("version"));
+			Assert.Equal(InstanceController.Version, v1.Body.Text("version"));
+			Assert.Equal(PrivaPubHost.Host, v1.Body.Text("uri"));
+			Assert.False(v1.Body.Flag("registrations"));
+			Assert.True(v1.Body["stats"].Number("user_count") >= 0);
+			Assert.Equal(5000, v1.Body["configuration"]!["statuses"].Number("max_characters"));
+			Assert.Equal(4, v1.Body["configuration"]!["polls"].Number("max_options"));
+			Assert.Contains("image/jpeg", v1.Body["configuration"]!["media_attachments"]!["supported_mime_types"]!.AsArray().Select(t => t!.GetValue<string>()));
+			Assert.Empty(v1.Body["rules"]!.AsArray());
+			Assert.Null(v1.Body["contact_account"]);
+			Assert.True(v1.Body.AsObject().ContainsKey("contact_account"));
+
+			var v2 = (await anonymous.Get("/api/v2/instance")).Ok();
+			Assert.Equal(InstanceController.Version, v2.Body.Text("version"));
+			Assert.Equal(PrivaPubHost.Host, v2.Body.Text("domain"));
+			Assert.Equal($"wss://{PrivaPubHost.Host}", v2.Body["configuration"]!["urls"].Text("streaming"));
+			Assert.False(v2.Body["registrations"].Flag("enabled"));
+			Assert.False(v2.Body["configuration"]!["translation"].Flag("enabled"));
+			Assert.Equal(7, v2.Body["api_versions"].Number("mastodon"));
+
+			var signedIn = await _host.Mastodon("reader");
+			Assert.Equal(InstanceController.Version, (await signedIn.Client.Get("/api/v1/instance")).Ok().Body.Text("version"));
+		}
+
+		[Fact]
+		public async Task The_instance_side_routes_answer_without_a_login()
+		{
+			var anonymous = _host.Client();
+
+			Assert.Empty((await anonymous.Get("/api/v1/instance/peers")).Ok().Array);
+			Assert.Empty((await anonymous.Get("/api/v1/instance/activity")).Ok().Array);
+			Assert.Empty((await anonymous.Get("/api/v1/instance/rules")).Ok().Array);
+			var extended = (await anonymous.Get("/api/v1/instance/extended_description")).Ok();
+			Assert.StartsWith("<p>", extended.Body.Text("content"));
+			Assert.EndsWith("T00:00:00.000Z", extended.Body.Text("updated_at"));
+		}
+
+		[Theory]
+		[InlineData("/api/v1/custom_emojis")]
+		[InlineData("/api/v1/announcements")]
+		[InlineData("/api/v1/trends")]
+		[InlineData("/api/v1/trends/tags")]
+		[InlineData("/api/v1/trends/statuses")]
+		[InlineData("/api/v1/trends/links")]
+		public async Task Public_stub_routes_answer_empty_lists_to_anyone(string path)
+		{
+			Assert.Empty((await _host.Client().Get(path)).Ok().Array);
+		}
+
+		[Theory]
+		[InlineData("/api/v1/filters")]
+		[InlineData("/api/v2/filters")]
+		[InlineData("/api/v1/lists")]
+		[InlineData("/api/v1/suggestions")]
+		[InlineData("/api/v2/suggestions")]
+		[InlineData("/api/v1/followed_tags")]
+		[InlineData("/api/v1/endorsements")]
+		[InlineData("/api/v1/featured_tags")]
+		[InlineData("/api/v1/scheduled_statuses")]
+		public async Task Signed_in_stub_routes_answer_empty_lists(string path)
+		{
+			var reader = await _host.Mastodon("reader");
+
+			Assert.Empty((await reader.Client.Get(path)).Ok().Array);
+			Assert.Equal(HttpStatusCode.Unauthorized, (await _host.Client().Get(path)).Status);
+		}
+
+		[Fact]
+		public async Task Apps_are_registered_validated_and_verified()
+		{
+			var anonymous = _host.Client();
+
+			var app = (await anonymous.Post("/api/v1/apps", ("client_name", "tusky-ish"), ("redirect_uris", "urn:ietf:wg:oauth:2.0:oob"), ("scopes", "read write"),
+				("website", "https://example.com"))).Ok();
+
+			Assert.Equal("tusky-ish", app.Body.Text("name"));
+			Assert.Equal(new[] { "read", "write" }, app.Body["scopes"]!.AsArray().Select(s => s!.GetValue<string>()));
+			Assert.False(string.IsNullOrEmpty(app.Body.Text("client_id")));
+			Assert.False(string.IsNullOrEmpty(app.Body.Text("client_secret")));
+			Assert.Equal(HttpStatusCode.UnprocessableEntity, (await anonymous.Post("/api/v1/apps", ("redirect_uris", "urn:ietf:wg:oauth:2.0:oob"))).Status);
+			Assert.Equal(HttpStatusCode.UnprocessableEntity, (await anonymous.Post("/api/v1/apps", ("client_name", "x"), ("redirect_uris", "javascript:alert(1)"))).Status);
+			Assert.Equal(HttpStatusCode.UnprocessableEntity, (await anonymous.Post("/api/v1/apps", ("client_name", "x"))).Status);
+
+			var reader = await _host.Mastodon("reader");
+			var verified = (await reader.Client.Get("/api/v1/apps/verify_credentials")).Ok();
+			Assert.Equal("privapub-tests", verified.Body.Text("name"));
+			Assert.Equal(HttpStatusCode.Unauthorized, (await anonymous.Get("/api/v1/apps/verify_credentials")).Status);
+		}
+
+		[Fact]
+		public async Task Preferences_follow_the_persona_and_push_has_no_subscription()
+		{
+			var reader = await _host.Mastodon("reader", scopes: "read write follow push");
+			(await reader.Client.Patch("/api/v1/accounts/update_credentials", ("source[privacy]", "unlisted"), ("source[sensitive]", "true"))).Ok();
+
+			var preferences = (await reader.Client.Get("/api/v1/preferences")).Ok();
+
+			Assert.Equal("unlisted", preferences.Body.Text("posting:default:visibility"));
+			Assert.True(preferences.Body.Flag("posting:default:sensitive"));
+			Assert.False(preferences.Body.Flag("reading:expand:spoilers"));
+			var push = await reader.Client.Get("/api/v1/push/subscription");
+			Assert.Equal(HttpStatusCode.NotFound, push.Status);
+			Assert.Equal("Record not found", push.Body.Text("error"));
+		}
+	}
+}