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

using System.Collections;
using System.Linq;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine.TestTools;

namespace Unity.Netcode.RuntimeTests
{
    /// <summary>
    /// Validates the client disconnection process.
    /// This assures that:
    /// - When a client disconnects from the server that the server:
    /// -- Detects the client disconnected.
    /// -- Cleans up the transport to NGO client (and vice versa) mappings.
    /// - When a server disconnects a client that:
    /// -- The client detects this disconnection.
    /// -- The server cleans up the transport to NGO client (and vice versa) mappings.
    /// - When <see cref="OwnerPersistence.DestroyWithOwner"/> the server-side player object is destroyed
    /// - When <see cref="OwnerPersistence.DontDestroyWithOwner"/> the server-side player object ownership is transferred back to the server
    /// </summary>
    [TestFixture(OwnerPersistence.DestroyWithOwner)]
    [TestFixture(OwnerPersistence.DontDestroyWithOwner)]
    public class DisconnectTests : NetcodeIntegrationTest
    {
        public enum OwnerPersistence
        {
            DestroyWithOwner,
            DontDestroyWithOwner
        }

        public enum ClientDisconnectType
        {
            ServerDisconnectsClient,
            ClientDisconnectsFromServer
        }

        protected override int NumberOfClients => 1;

        private OwnerPersistence m_OwnerPersistence;
        private bool m_ClientDisconnected;
        private ulong m_TransportClientId;
        private ulong m_ClientId;


        public DisconnectTests(OwnerPersistence ownerPersistence)
        {
            m_OwnerPersistence = ownerPersistence;
        }

        protected override void OnCreatePlayerPrefab()
        {
            m_PlayerPrefab.GetComponent<NetworkObject>().DontDestroyWithOwner = m_OwnerPersistence == OwnerPersistence.DontDestroyWithOwner;
            base.OnCreatePlayerPrefab();
        }

        protected override void OnServerAndClientsCreated()
        {
            // Adjusting client and server timeout periods to reduce test time
            // Get the tick frequency in milliseconds and triple it for the heartbeat timeout
            var heartBeatTimeout = (int)(300 * (1.0f / m_ServerNetworkManager.NetworkConfig.TickRate));
            var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
            if (unityTransport != null)
            {
                unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
            }

            unityTransport = m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
            if (unityTransport != null)
            {
                unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
            }

            base.OnServerAndClientsCreated();
        }

        protected override IEnumerator OnSetup()
        {
            m_ClientDisconnected = false;
            m_ClientId = 0;
            m_TransportClientId = 0;
            return base.OnSetup();
        }

        /// <summary>
        /// Used to detect the client disconnected on the server side
        /// </summary>
        private void OnClientDisconnectCallback(ulong obj)
        {
            m_ClientDisconnected = true;
        }

        /// <summary>
        /// Conditional check to assure the transport to client (and vice versa) mappings are cleaned up
        /// </summary>
        private bool TransportIdCleanedUp()
        {
            if (m_ServerNetworkManager.ConnectionManager.TransportIdToClientId(m_TransportClientId) == m_ClientId)
            {
                return false;
            }

            if (m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId) == m_TransportClientId)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// Conditional check to make sure the client player object no longer exists on the server side
        /// </summary>
        private bool DoesServerStillHaveSpawnedPlayerObject()
        {
            if (m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId].ContainsKey(m_ClientId))
            {
                var playerObject = m_PlayerNetworkObjects[m_ServerNetworkManager.LocalClientId][m_ClientId];
                if (playerObject != null && playerObject.IsSpawned)
                {
                    return false;
                }
            }
            return !m_ServerNetworkManager.SpawnManager.SpawnedObjects.Any(x => x.Value.IsPlayerObject && x.Value.OwnerClientId == m_ClientId);
        }

        [UnityTest]
        public IEnumerator ClientPlayerDisconnected([Values] ClientDisconnectType clientDisconnectType)
        {
            m_ClientId = m_ClientNetworkManagers[0].LocalClientId;

            var serverSideClientPlayer = m_ServerNetworkManager.ConnectionManager.ConnectedClients[m_ClientId].PlayerObject;

            m_TransportClientId = m_ServerNetworkManager.ConnectionManager.ClientIdToTransportId(m_ClientId);

            if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
            {
                m_ClientNetworkManagers[0].OnClientDisconnectCallback += OnClientDisconnectCallback;
                m_ServerNetworkManager.DisconnectClient(m_ClientId);
            }
            else
            {
                m_ServerNetworkManager.OnClientDisconnectCallback += OnClientDisconnectCallback;

                yield return StopOneClient(m_ClientNetworkManagers[0]);
            }

            yield return WaitForConditionOrTimeOut(() => m_ClientDisconnected);
            AssertOnTimeout("Timed out waiting for client to disconnect!");

            if (m_OwnerPersistence == OwnerPersistence.DestroyWithOwner)
            {
                // When we are destroying with the owner, validate the player object is destroyed on the server side
                yield return WaitForConditionOrTimeOut(DoesServerStillHaveSpawnedPlayerObject);
                AssertOnTimeout("Timed out waiting for client's player object to be destroyed!");
            }
            else
            {
                // When we are not destroying with the owner, ensure the player object's ownership was transferred back to the server
                yield return WaitForConditionOrTimeOut(() => serverSideClientPlayer.IsOwnedByServer);
                AssertOnTimeout("The client's player object's ownership was not transferred back to the server!");
            }

            yield return WaitForConditionOrTimeOut(TransportIdCleanedUp);
            AssertOnTimeout("Timed out waiting for transport and client id mappings to be cleaned up!");
        }
    }
}