SocialPub/PrivaPub.Tests/Federation/InboundRoutingTests.cs

using MongoDB.Entities;

using PrivaPub.ClientModels.Post;
using PrivaPub.Federation.Objects;
using PrivaPub.Models.Group;
using PrivaPub.Models.Post;
using PrivaPub.Tests.Support;

using System.Text.Json.Nodes;

namespace PrivaPub.Tests.Federation
{
	[Trait("Category", "Integration")]
	public sealed class InboundRoutingTests : IAsyncLifetime
	{
		Harness _harness;

		public async ValueTask InitializeAsync()
		{
			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
			_harness = await Harness.Start();
		}

		public async ValueTask DisposeAsync()
		{
			if (_harness != default)
				await _harness.DisposeAsync();
		}

		static string Origin(RemoteActor actor) => new Uri(actor.Id).GetLeftPart(UriPartial.Authority);

		static string NewId(RemoteActor actor, string kind) => $"{Origin(actor)}/{kind}/{Guid.NewGuid():N}";

		async Task<Post> LocalPost(string text)
		{
			var (root, alice) = await _harness.Persona("alice");
			await _harness.Posts.InsertPost(root, new InsertPostForm { AvatarId = alice.Id, Text = text }, TestContext.Current.CancellationToken);
			return await DB.Default.Find<Post>().Match(p => p.GroupUserId == alice.Id).ExecuteFirstAsync(TestContext.Current.CancellationToken);
		}

		[Fact]
		public async Task A_downvote_counts_and_its_undo_takes_it_back()
		{
			var token = TestContext.Current.CancellationToken;
			var post = await LocalPost("vote on me");
			var lemmy = new RemoteActor(_harness.Peer, "voter");
			var dislike = new JsonObject { ["id"] = NewId(lemmy, "activities/dislike"), ["type"] = "Dislike", ["actor"] = lemmy.Id, ["object"] = post.ObjectURI };

			await _harness.Deliver(lemmy, "/human-centipede", dislike);
			Assert.Equal(1, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).DownvotesCount);

			await _harness.Deliver(lemmy, "/human-centipede", new JsonObject
			{
				["id"] = NewId(lemmy, "activities/undo"), ["type"] = "Undo", ["actor"] = lemmy.Id, ["object"] = dislike.DeepClone()
			});
			Assert.Equal(0, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).DownvotesCount);
		}

		[Fact]
		public async Task A_delete_that_arrives_first_keeps_the_post_from_coming_back()
		{
			var token = TestContext.Current.CancellationToken;
			var (_, alice) = await _harness.Persona("alice");
			var mallory = new RemoteActor(_harness.Peer, "mallory");
			var noteId = NewId(mallory, "notes");

			await _harness.Deliver(mallory, "/human-centipede", new JsonObject
			{
				["id"] = NewId(mallory, "activities/delete"), ["type"] = "Delete", ["actor"] = mallory.Id,
				["object"] = new JsonObject { ["id"] = noteId, ["type"] = "Tombstone" }
			});
			await _harness.Deliver(mallory, "/human-centipede", new JsonObject
			{
				["id"] = NewId(mallory, "activities/create"), ["type"] = "Create", ["actor"] = mallory.Id,
				["object"] = new JsonObject
				{
					["id"] = noteId, ["type"] = "Note", ["attributedTo"] = mallory.Id, ["content"] = "<p>late</p>",
					["to"] = new JsonArray(Addressing.Public), ["cc"] = new JsonArray(alice.Uri),
					["tag"] = new JsonArray(new JsonObject { ["type"] = "Mention", ["href"] = alice.Uri, ["name"] = "@alice" })
				}
			});

			Assert.False(await DB.Default.Find<Post>().Match(p => p.ObjectURI == noteId).ExecuteAnyAsync(token));
		}

		[Fact]
		public async Task A_lemmy_private_message_arrives_as_a_direct_message()
		{
			var token = TestContext.Current.CancellationToken;
			var (_, alice) = await _harness.Persona("alice");
			var lemmy = new RemoteActor(_harness.Peer, "pm");
			var messageId = NewId(lemmy, "private_message");

			await _harness.Deliver(lemmy, "/human-centipede", new JsonObject
			{
				["id"] = NewId(lemmy, "activities/create"), ["type"] = "Create", ["actor"] = lemmy.Id, ["to"] = new JsonArray(alice.Uri),
				["object"] = new JsonObject
				{
					["id"] = messageId, ["type"] = "ChatMessage", ["attributedTo"] = lemmy.Id, ["to"] = new JsonArray(alice.Uri),
					["content"] = "<p>psst</p>", ["mediaType"] = "text/html", ["published"] = DateTime.UtcNow.ToString("O")
				}
			});

			var message = await DB.Default.Find<Post>().Match(p => p.ObjectURI == messageId).ExecuteFirstAsync(token);
			Assert.NotNull(message);
			Assert.Equal(PostVisibility.Direct, message.Visibility);
			Assert.NotNull(message.ConversationId);
		}

		// Mbin addresses its private messages to the recipient's profile page (its `url`), not to the actor
		[Fact]
		public async Task A_chat_message_addressed_to_a_personas_profile_page_reaches_the_persona()
		{
			var token = TestContext.Current.CancellationToken;
			var (_, alice) = await _harness.Persona("alice");
			var mbin = new RemoteActor(_harness.Peer, "mbuser");
			var messageId = NewId(mbin, "f/object");

			await _harness.Deliver(mbin, "/human-centipede", new JsonObject
			{
				["id"] = NewId(mbin, "f/object"), ["type"] = "Create", ["actor"] = mbin.Id, ["to"] = new JsonArray(alice.HtmlUrl), ["cc"] = new JsonArray(),
				["object"] = new JsonObject
				{
					["id"] = messageId, ["type"] = "ChatMessage", ["attributedTo"] = mbin.Id, ["to"] = new JsonArray(alice.HtmlUrl), ["cc"] = new JsonArray(),
					["content"] = "<p>an answer</p>", ["mediaType"] = "text/html", ["published"] = DateTime.UtcNow.ToString("O")
				}
			});

			var message = await DB.Default.Find<Post>().Match(p => p.ObjectURI == messageId).ExecuteFirstAsync(token);
			Assert.NotNull(message);
			Assert.Equal(PostVisibility.Direct, message.Visibility);
			var conversation = await DB.Default.Find<DmGroup>().OneAsync(message.ConversationId, token);
			Assert.Equal(new[] { alice.Id, mbin.Id }.Order(StringComparer.Ordinal), conversation.Members.Select(m => m.AvatarId).Order(StringComparer.Ordinal));
		}

		// Lemmy 0.19 and Mbin take a private message only as a ChatMessage: someone who writes to us that way is answered in
		// kind, anyone else with a Note
		[Fact]
		public async Task A_direct_message_answers_in_the_form_its_recipient_writes_in()
		{
			var token = TestContext.Current.CancellationToken;
			var (_, alice) = await _harness.Persona("alice");
			var lemmy = new RemoteActor(_harness.Peer, "pm");
			var mastodon = new RemoteActor(_harness.Peer, "dm");
			async Task<Post> Received(RemoteActor sender, string type)
			{
				var id = NewId(sender, "messages");
				await _harness.Deliver(sender, "/human-centipede", new JsonObject
				{
					["id"] = NewId(sender, "activities/create"), ["type"] = "Create", ["actor"] = sender.Id, ["to"] = new JsonArray(alice.Uri),
					["object"] = new JsonObject
					{
						["id"] = id, ["type"] = type, ["attributedTo"] = sender.Id, ["to"] = new JsonArray(alice.Uri),
						["content"] = "<p>psst</p>", ["published"] = DateTime.UtcNow.ToString("O")
					}
				});
				return await DB.Default.Find<Post>().Match(p => p.ObjectURI == id).ExecuteSingleAsync(token);
			}
			async Task<JsonObject> Answer(RemoteActor to, Post message)
			{
				var answer = await _harness.Statuses.Publish(alice, new PrivaPub.Domain.Statuses.StatusDraft
				{
					Text = "psst back", Visibility = PostVisibility.Direct, ConversationId = message.ConversationId
				}, token);
				Assert.True(answer.Ok, answer.Error);
				return (JsonObject)(await _harness.Outgoing(to.Id + "/inbox")).Last(a => a["type"]!.GetValue<string>() == "Create")["object"]!;
			}

			var chat = await Answer(lemmy, await Received(lemmy, "ChatMessage"));
			var note = await Answer(mastodon, await Received(mastodon, "Note"));

			Assert.Equal("ChatMessage", chat["type"]!.GetValue<string>());
			Assert.Equal(lemmy.Id, Assert.Single(chat["to"]!.AsArray())!.GetValue<string>());
			Assert.Null(chat["cc"]);
			Assert.DoesNotContain("h-card", chat["content"]!.GetValue<string>());
			Assert.Equal("Note", note["type"]!.GetValue<string>());
		}

		[Fact]
		public async Task An_unreachable_key_asks_the_sender_to_retry_instead_of_refusing()
		{
			var (_, alice) = await _harness.Persona("alice");
			var offline = new RemoteActor(_harness.Peer, "offline", origin: "http://127.0.0.1:9");

			var result = await _harness.Deliver(offline, "/human-centipede", new JsonObject
			{
				["id"] = NewId(offline, "follows"), ["type"] = "Follow", ["actor"] = offline.Id, ["object"] = alice.Uri
			});

			Assert.Equal(503, result.StatusCode);
			Assert.Equal(300, result.RetryAfterSeconds);
		}

		[Fact]
		public async Task A_join_of_a_local_post_is_answered_with_ignore()
		{
			var post = await LocalPost("not an event");
			var mobilizon = new RemoteActor(_harness.Peer, "joiner");

			await _harness.Deliver(mobilizon, "/human-centipede", new JsonObject
			{
				["id"] = NewId(mobilizon, "join"), ["type"] = "Join", ["actor"] = mobilizon.Id, ["object"] = post.ObjectURI
			});

			var answer = Assert.Single(await _harness.Outgoing(mobilizon.Id + "/inbox"));
			Assert.Equal("Ignore", answer["type"]!.GetValue<string>());
		}
	}
}