5dplomacy/MultiversalDiplomacyTests/SerializationTest.cs

using System.Text.Json;

using MultiversalDiplomacy.Adjudicate;
using MultiversalDiplomacy.Model;

using NUnit.Framework;

namespace MultiversalDiplomacyTests;

public class SerializationTest
{
    [Test]
    public void SerializeRoundTrip_NewGame()
    {
        JsonSerializerOptions options = new() {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        };

        World world = World.WithStandardMap();
        string serialized = JsonSerializer.Serialize(world, options);
        Console.WriteLine(serialized);
        World? deserialized = JsonSerializer.Deserialize<World>(serialized, options);
        Assert.That(deserialized, Is.Not.Null, "Failed to deserialize");
    }

    [Test]
    public void SerializeRoundTrip_MDATC_3_A_2()
    {
        // Set up MDATC 3.A.2
        TestCaseBuilder setup = new(World.WithStandardMap(), MovementPhaseAdjudicator.Instance);
        setup[("a", 0)]
            .GetReference(out Season s0)
            ["Germany"]
                .Army("Mun").MovesTo("Tyr").GetReference(out var mun0)
            ["Austria"]
                .Army("Tyr").Holds().GetReference(out var tyr0);

        setup.ValidateOrders();
        Assert.That(mun0, Is.Valid);
        Assert.That(tyr0, Is.Valid);
        setup.AdjudicateOrders();
        Assert.That(mun0, Is.Repelled);
        Assert.That(tyr0, Is.NotDislodged);
        setup.UpdateWorld();

        // Serialize the world
        JsonSerializerOptions options = new() {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        };
        JsonElement serialized = JsonSerializer.SerializeToDocument(setup.World, options).RootElement;

        Assert.That(
            serialized.EnumerateObject().Select(prop => prop.Name),
            Is.EquivalentTo(new List<string> {
                "mapType",
                "seasons",
                "units",
                "retreatingUnits",
                "orderHistory",
                "options",
            }));

        // Deserialize the world
        World reserialized = JsonSerializer.Deserialize<World>(serialized)
            ?? throw new AssertionException("Failed to reserialize world");

        // Resume the test case
        setup = new(reserialized, MovementPhaseAdjudicator.Instance);
        setup[("a", 1)]
            ["Germany"]
                .Army("Mun").Supports.Army("Mun", season: reserialized.GetSeason("a0")).MoveTo("Tyr").GetReference(out var mun1)
            ["Austria"]
                .Army("Tyr").Holds();

        setup.ValidateOrders();
        Assert.That(mun1, Is.Valid);
        setup.AdjudicateOrders();
        Assert.That(mun1, Is.NotCut);
        Assert.That(mun0, Is.Victorious);
        Assert.That(tyr0, Is.Dislodged);

        // Confirm that an alternate future is created.
        World world = setup.UpdateWorld();
        Season fork = world.GetSeason("b1");
        Unit tyr1 = world.GetUnitAt("Tyr", fork);
        Assert.That(
            tyr1.Past,
            Is.EqualTo(mun0.Order.Unit),
            "Expected A Mun a0 to advance to Tyr b1");
        Assert.That(
            world.RetreatingUnits.Count,
            Is.EqualTo(1),
            "Expected A Tyr a0 to be in retreat");
        Assert.That(world.RetreatingUnits.First().Unit, Is.EqualTo(tyr0.Order.Unit));
    }
}