test

adding validation test for the fix.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Tests/Runtime/PlayerObjectTests.cs

@@ -1,4 +1,7 @@
 using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using NUnit.Framework;
 using Unity.Netcode.TestHelpers.Runtime;
 using UnityEngine;
@@ -184,4 +187,152 @@ public IEnumerator PlayerSpawnPosition()
             }
         }
     }
+
+    /// <summary>
+    /// This test validates that when a player is spawned it has all observers
+    /// properly set and the spawned and player object lists are properly populated.
+    /// It also validates that when a player is despawned and the client is still connected
+    /// that the client maintains its observers for other players.
+    /// </summary>
+    [TestFixture(HostOrServer.DAHost)]
+    [TestFixture(HostOrServer.Host)]
+    [TestFixture(HostOrServer.Server)]
+    internal class PlayerSpawnAndDespawnTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 4;
+
+        private List<NetworkManager> m_NetworkManagers = new List<NetworkManager>();
+        private StringBuilder m_ErrorLog = new StringBuilder();
+
+        public PlayerSpawnAndDespawnTests(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+        protected override IEnumerator OnTearDown()
+        {
+            // Always clear in case test fails
+            m_NetworkManagers.Clear();
+            return base.OnTearDown();
+        }
+
+        private bool ValidateObservers(ulong playerClientId, NetworkObject player)
+        {
+            foreach (var networkManager in m_NetworkManagers)
+            {
+                if (player != null && player.IsSpawned)
+                {
+                    if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(player.NetworkObjectId))
+                    {
+                        m_ErrorLog.AppendLine($"Client-{networkManager.LocalClientId} does not contain a spawned object entry {nameof(NetworkObject)}-{player.NetworkObjectId} for Client-{playerClientId}!");
+                        return false;
+                    }
+
+                    var playerClone = networkManager.SpawnManager.SpawnedObjects[player.NetworkObjectId];
+                    foreach (var clientId in networkManager.ConnectedClientsIds)
+                    {
+                        if (!playerClone.IsNetworkVisibleTo(clientId))
+                        {
+                            m_ErrorLog.AppendLine($"Client-{networkManager.LocalClientId} failed visibility check for Client-{clientId} on {nameof(NetworkObject)}-{player.NetworkObjectId} for Client-{playerClientId}!");
+                            return false;
+                        }
+                    }
+
+                    var foundPlayerClone = (NetworkObject)null;
+                    foreach (var playerObject in networkManager.SpawnManager.PlayerObjects)
+                    {
+                        if (playerObject.OwnerClientId == playerClientId && playerObject.NetworkObjectId == player.NetworkObjectId)
+                        {
+                            foundPlayerClone = playerObject;
+                            break;
+                        }
+                    }
+                    if (!foundPlayerClone)
+                    {
+                        m_ErrorLog.AppendLine($"Client-{networkManager.LocalClientId} does not contain a player entry for {nameof(NetworkObject)}-{player.NetworkObjectId} for Client-{playerClientId}!");
+                        return false;
+                    }
+
+                }
+                else
+                {
+                    // If the player client in question is despawned, then no NetworkManager instance
+                    // should contain a clone of that (or the client's NetworkManager instance as well)
+                    foreach (var playerClone in networkManager.SpawnManager.PlayerObjects)
+                    {
+                        if (playerClone.OwnerClientId == playerClientId)
+                        {
+                            m_ErrorLog.AppendLine($"Client-{networkManager.LocalClientId} contains a player {nameof(NetworkObject)}-{playerClone.NetworkObjectId} for Client-{playerClientId} when it should be despawned!");
+                            return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+
+        private bool ValidateAllClientPlayerObservers()
+        {
+            m_ErrorLog.Clear();
+            foreach (var networkManager in m_NetworkManagers)
+            {
+                var spawnedOrNot = networkManager.LocalClient.PlayerObject == null ? "despawned" : "spawned";
+                m_ErrorLog.AppendLine($"Validating Client-{networkManager.LocalClientId} {spawnedOrNot} player.");
+                if (networkManager.LocalClient == null)
+                {
+                    m_ErrorLog.AppendLine($"No {nameof(NetworkClient)} found for Client-{networkManager.LocalClientId}!");
+                    return false;
+                }
+                if (!ValidateObservers(networkManager.LocalClientId, networkManager.LocalClient.PlayerObject))
+                {
+                    m_ErrorLog.AppendLine($"Client-{networkManager.LocalClientId} validation pass failed.");
+                    return false;
+                }
+            }
+            return true;
+        }
+
+
+        [UnityTest]
+        public IEnumerator PlayerSpawnDespawn()
+        {
+            if (m_ServerNetworkManager.IsHost)
+            {
+                m_NetworkManagers.Add(m_ServerNetworkManager);
+            }
+            m_NetworkManagers.AddRange(m_ClientNetworkManagers);
+
+            // Validate all observers are properly set with all players spawned
+            yield return WaitForConditionOrTimeOut(ValidateAllClientPlayerObservers);
+            AssertOnTimeout($"First Validation Failed:\n {m_ErrorLog}");
+            var selectedClient = m_ClientNetworkManagers[Random.Range(0, m_ClientNetworkManagers.Count() - 1)];
+            var playerSelected = selectedClient.LocalClient.PlayerObject;
+
+            if (m_DistributedAuthority)
+            {
+                playerSelected.Despawn(false);
+            }
+            else
+            {
+                m_ServerNetworkManager.SpawnManager.SpawnedObjects[playerSelected.NetworkObjectId].Despawn(false);
+            }
+
+            // Validate all observers are properly set with one of the players despawned
+            yield return WaitForConditionOrTimeOut(ValidateAllClientPlayerObservers);
+            AssertOnTimeout($"Second Validation Failed:\n {m_ErrorLog}");
+
+            if (m_DistributedAuthority)
+            {
+                playerSelected.SpawnAsPlayerObject(selectedClient.LocalClientId, false);
+            }
+            else
+            {
+                var serverPlayerInstance = Object.Instantiate(m_ServerNetworkManager.NetworkConfig.PlayerPrefab);
+                serverPlayerInstance.GetComponent<NetworkObject>().SpawnAsPlayerObject(selectedClient.LocalClientId, false);
+            }
+
+            // Validate all observers are properly set when the client's player is respawned.
+            yield return WaitForConditionOrTimeOut(ValidateAllClientPlayerObservers);
+            AssertOnTimeout($"Third Validation Failed:\n {m_ErrorLog}");
+
+            m_NetworkManagers.Clear();
+        }
+    }
 }