Improve CreateDeleteCreateTest failure messages (#40996)

* Improve CreateDeleteCreateTest failure messages

* nameof

diff --git a/Content.IntegrationTests/Tests/Lobby/CharacterCreationTest.cs b/Content.IntegrationTests/Tests/Lobby/CharacterCreationTest.cs
index 60501a781fc58ad16b53daf64390ee201ca2f369..d5791861cf655a31acd75af8a004d3b7223ec7d0 100644 (file)
--- a/Content.IntegrationTests/Tests/Lobby/CharacterCreationTest.cs
+++ b/Content.IntegrationTests/Tests/Lobby/CharacterCreationTest.cs
@@ -1,114 +1,122 @@
 using Content.Client.Lobby;
 using Content.Server.Preferences.Managers;
+using Content.Shared.Humanoid;
 using Content.Shared.Preferences;
 using Robust.Client.State;
-using Robust.Shared.Network;
 
-namespace Content.IntegrationTests.Tests.Lobby
+namespace Content.IntegrationTests.Tests.Lobby;
+
+[TestFixture]
+[TestOf(typeof(ClientPreferencesManager))]
+[TestOf(typeof(ServerPreferencesManager))]
+public sealed class CharacterCreationTest
 {
-    [TestFixture]
-    [TestOf(typeof(ClientPreferencesManager))]
-    [TestOf(typeof(ServerPreferencesManager))]
-    public sealed class CharacterCreationTest
+    [Test]
+    public async Task CreateDeleteCreateTest()
     {
-        [Test]
-        public async Task CreateDeleteCreateTest()
+        await using var pair = await PoolManager.GetServerClient(new PoolSettings { InLobby = true });
+        var server = pair.Server;
+        var client = pair.Client;
+        var user = pair.Client.User!.Value;
+        var clientPrefManager = client.Resolve<IClientPreferencesManager>();
+        var serverPrefManager = server.Resolve<IServerPreferencesManager>();
+
+        Assert.That(client.Resolve<IStateManager>().CurrentState, Is.TypeOf<LobbyState>());
+        await client.WaitPost(() => clientPrefManager.SelectCharacter(0));
+        await pair.RunTicksSync(5);
+
+        var clientCharacters = clientPrefManager.Preferences?.Characters;
+        Assert.That(clientCharacters, Is.Not.Null);
+        Assert.That(clientCharacters, Has.Count.EqualTo(1));
+
+        HumanoidCharacterProfile profile = null;
+        await client.WaitPost(() =>
         {
-            await using var pair = await PoolManager.GetServerClient(new PoolSettings { InLobby = true });
-            var server = pair.Server;
-            var client = pair.Client;
-
-            var clientNetManager = client.ResolveDependency<IClientNetManager>();
-            var clientStateManager = client.ResolveDependency<IStateManager>();
-            var clientPrefManager = client.ResolveDependency<IClientPreferencesManager>();
-
-            var serverPrefManager = server.ResolveDependency<IServerPreferencesManager>();
-
-
-            // Need to run them in sync to receive the messages.
-            await pair.RunTicksSync(1);
-
-            await PoolManager.WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, 600);
-
-            Assert.That(clientNetManager.ServerChannel, Is.Not.Null);
-
-            var clientNetId = clientNetManager.ServerChannel.UserId;
-            HumanoidCharacterProfile profile = null;
-
-            await client.WaitAssertion(() =>
-            {
-                clientPrefManager.SelectCharacter(0);
-
-                var clientCharacters = clientPrefManager.Preferences?.Characters;
-                Assert.That(clientCharacters, Is.Not.Null);
-                Assert.Multiple(() =>
-                {
-                    Assert.That(clientCharacters, Has.Count.EqualTo(1));
-
-                    Assert.That(clientStateManager.CurrentState, Is.TypeOf<LobbyState>());
-                });
-
-                profile = HumanoidCharacterProfile.Random();
-                clientPrefManager.CreateCharacter(profile);
-
-                clientCharacters = clientPrefManager.Preferences?.Characters;
-
-                Assert.That(clientCharacters, Is.Not.Null);
-                Assert.That(clientCharacters, Has.Count.EqualTo(2));
-                Assert.That(clientCharacters[1].MemberwiseEquals(profile));
-            });
+            profile = HumanoidCharacterProfile.Random();
+            clientPrefManager.CreateCharacter(profile);
+        });
+        await pair.RunTicksSync(5);
 
-            await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60);
+        clientCharacters = clientPrefManager.Preferences?.Characters;
+        Assert.That(clientCharacters, Is.Not.Null);
+        Assert.That(clientCharacters, Has.Count.EqualTo(2));
+        AssertEqual(clientCharacters[1], profile);
 
-            await server.WaitAssertion(() =>
-            {
-                var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
+        await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(user).Characters.Count == 2, maxTicks: 60);
 
-                Assert.That(serverCharacters, Has.Count.EqualTo(2));
-                Assert.That(serverCharacters[1].MemberwiseEquals(profile));
-            });
+        var serverCharacters = serverPrefManager.GetPreferences(user).Characters;
+        Assert.That(serverCharacters, Has.Count.EqualTo(2));
+        AssertEqual(serverCharacters[1], profile);
 
-            await client.WaitAssertion(() =>
-            {
-                clientPrefManager.DeleteCharacter(1);
+        await client.WaitAssertion(() => clientPrefManager.DeleteCharacter(1));
+        await pair.RunTicksSync(5);
+        Assert.That(clientPrefManager.Preferences?.Characters.Count, Is.EqualTo(1));
+        await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(user).Characters.Count == 1, maxTicks: 60);
+        Assert.That(serverPrefManager.GetPreferences(user).Characters.Count, Is.EqualTo(1));
 
-                var clientCharacters = clientPrefManager.Preferences?.Characters.Count;
-                Assert.That(clientCharacters, Is.EqualTo(1));
-            });
+        await client.WaitIdleAsync();
 
-            await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks: 60);
-
-            await server.WaitAssertion(() =>
-            {
-                var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters.Count;
-                Assert.That(serverCharacters, Is.EqualTo(1));
-            });
-
-            await client.WaitIdleAsync();
-
-            await client.WaitAssertion(() =>
-            {
-                profile = HumanoidCharacterProfile.Random();
-
-                clientPrefManager.CreateCharacter(profile);
-
-                var clientCharacters = clientPrefManager.Preferences?.Characters;
+        await client.WaitAssertion(() =>
+        {
+            profile = HumanoidCharacterProfile.Random();
+            clientPrefManager.CreateCharacter(profile);
+        });
+        await pair.RunTicksSync(5);
+
+        clientCharacters = clientPrefManager.Preferences?.Characters;
+        Assert.That(clientCharacters, Is.Not.Null);
+        Assert.That(clientCharacters, Has.Count.EqualTo(2));
+        AssertEqual(clientCharacters[1], profile);
+
+        await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(user).Characters.Count == 2, maxTicks: 60);
+        serverCharacters = serverPrefManager.GetPreferences(user).Characters;
+        Assert.That(serverCharacters, Has.Count.EqualTo(2));
+        AssertEqual(serverCharacters[1], profile);
+        await pair.CleanReturnAsync();
+    }
 
-                Assert.That(clientCharacters, Is.Not.Null);
-                Assert.That(clientCharacters, Has.Count.EqualTo(2));
-                Assert.That(clientCharacters[1].MemberwiseEquals(profile));
-            });
+    private void AssertEqual(ICharacterProfile clientCharacter, HumanoidCharacterProfile b)
+    {
+        if (clientCharacter.MemberwiseEquals(b))
+            return;
 
-            await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60);
+        if (clientCharacter is not HumanoidCharacterProfile a)
+        {
+            Assert.Fail($"Not a {nameof(HumanoidCharacterProfile)}");
+            return;
+        }
 
-            await server.WaitAssertion(() =>
-            {
-                var serverCharacters = serverPrefManager.GetPreferences(clientNetId).Characters;
+        Assert.Multiple(() =>
+        {
+            Assert.That(a.Name, Is.EqualTo(b.Name));
+            Assert.That(a.Age, Is.EqualTo(b.Age));
+            Assert.That(a.Sex, Is.EqualTo(b.Sex));
+            Assert.That(a.Gender, Is.EqualTo(b.Gender));
+            Assert.That(a.Species, Is.EqualTo(b.Species));
+            Assert.That(a.PreferenceUnavailable, Is.EqualTo(b.PreferenceUnavailable));
+            Assert.That(a.SpawnPriority, Is.EqualTo(b.SpawnPriority));
+            Assert.That(a.FlavorText, Is.EqualTo(b.FlavorText));
+            Assert.That(a.JobPriorities, Is.EquivalentTo(b.JobPriorities));
+            Assert.That(a.AntagPreferences, Is.EquivalentTo(b.AntagPreferences));
+            Assert.That(a.TraitPreferences, Is.EquivalentTo(b.TraitPreferences));
+            Assert.That(a.Loadouts, Is.EquivalentTo(b.Loadouts));
+            AssertEqual(a.Appearance, b.Appearance);
+            Assert.Fail("Profile not equal");
+        });
+    }
 
-                Assert.That(serverCharacters, Has.Count.EqualTo(2));
-                Assert.That(serverCharacters[1].MemberwiseEquals(profile));
-            });
-            await pair.CleanReturnAsync();
-        }
+    private void AssertEqual(HumanoidCharacterAppearance a, HumanoidCharacterAppearance b)
+    {
+        if (a.MemberwiseEquals(b))
+            return;
+
+        Assert.That(a.HairStyleId, Is.EqualTo(b.HairStyleId));
+        Assert.That(a.HairColor, Is.EqualTo(b.HairColor));
+        Assert.That(a.FacialHairStyleId, Is.EqualTo(b.FacialHairStyleId));
+        Assert.That(a.FacialHairColor, Is.EqualTo(b.FacialHairColor));
+        Assert.That(a.EyeColor, Is.EqualTo(b.EyeColor));
+        Assert.That(a.SkinColor, Is.EqualTo(b.SkinColor));
+        Assert.That(a.Markings, Is.EquivalentTo(b.Markings));
+        Assert.Fail("Appearance not equal");
     }
 }