Rendezvous/tests/FinalFactory.Rendezvous.Tests/Server/UdpMediatorServiceTests.cs

using System.Net;
using FinalFactory.Rendezvous.Contracts;
using FinalFactory.Rendezvous.Server.Sessions;
using FinalFactory.Rendezvous.Server.State;
using FinalFactory.Rendezvous.Server.Transport;
using FinalFactory.Rendezvous.Tests.Sessions;
using FinalFactory.Rendezvous.Tests.State;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;

namespace FinalFactory.Rendezvous.Tests.Server;

public sealed class UdpMediatorServiceTests
{
    [Fact]
    public void AuthenticatedHostDatagramGatesVisibilityUsingObservedGameplaySocket()
    {
        using SessionLeaseFixture fixture = new();
        RegisterSessionResponse registration = fixture.Register();
        using UdpMediatorService service = new(
            Options.Create(new UdpMediatorOptions { ListenAddress = "127.0.0.1", Port = 0 }),
            NullLogger<UdpMediatorService>.Instance,
            fixture.Store,
            fixture.Capabilities);
        PresenceDatagram presence = new()
        {
            MessageType = UdpPresenceMessageType.HostPresence,
            MediationHandle = registration.HostPresenceHandle,
            AddressFamily = AddressFamilyKind.Ipv4,
            LocalAddress = "192.168.1.50",
            LocalPort = 40_000,
            Capability = registration.HostPresenceCapability,
        };
        IPEndPoint observedGameplaySocket = new(IPAddress.Parse("203.0.113.77"), 51_234);
        presence.Capability = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
        Assert.Equal(
            UdpPresenceProcessingResult.HostPresenceRejected,
            service.ProcessDatagram(RendezvousUdpCodec.Encode(presence), observedGameplaySocket));
        Assert.Empty(fixture.Browse());

        presence.Capability = registration.HostPresenceCapability;
        Assert.Equal(
            UdpPresenceProcessingResult.HostPresenceAccepted,
            service.ProcessDatagram(RendezvousUdpCodec.Encode(presence), observedGameplaySocket));
        Assert.Equal(registration.ListingId, Assert.Single(fixture.Browse()).Definition.ListingId);
    }

    [Fact]
    public async Task ServiceBindsAnEphemeralUdpPortAndStopsCleanly()
    {
        using CancellationTokenSource timeout = new(TimeSpan.FromSeconds(5));
        UdpMediatorOptions options = new()
        {
            ListenAddress = IPAddress.Loopback.ToString(),
            Port = 0,
        };
        ManualRendezvousClock clock = new();
        InMemoryEphemeralRendezvousStore store = new(new EphemeralStoreOptions(), clock, clock);
        using EphemeralCapabilityIssuer capabilities = new();
        using UdpMediatorService service = new(
            Options.Create(options),
            NullLogger<UdpMediatorService>.Instance,
            store,
            capabilities);

        await service.StartAsync(timeout.Token);

        IPEndPoint? boundEndpoint = service.LocalEndpoint;
        Assert.NotNull(boundEndpoint);
        Assert.Equal(IPAddress.Loopback, boundEndpoint.Address);
        Assert.InRange(boundEndpoint.Port, 1, 65_535);

        await service.StopAsync(timeout.Token);

        Assert.Null(service.LocalEndpoint);
    }
}