test: add RpcQueue unit tests

com.unity.multiplayer.mlapi/Tests/Runtime/RPCQueueTests.cs

@@ -0,0 +1,110 @@
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using UnityEngine.TestTools;
+using MLAPI.SceneManagement;
+using MLAPI.Transports.UNET;
+
+namespace MLAPI.RuntimeTests
+{
+    public class RPCQueueTests
+    {
+        private NetworkingManager m_NetMan;
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            yield return new EnterPlayMode();
+        }
+
+        /// <summary>
+        /// RPCQueueUnitTest
+        /// Tests the egress and ingress RPC queue functionality
+        /// ** This does not include any of the MLAPI to Transport code **
+        /// </summary>
+        /// <returns>IEnumerator</returns>
+        [UnityTest]
+        public IEnumerator RPCQueueUnitTest()
+        {
+            var NetManObject = new GameObject();
+            m_NetMan = NetManObject.AddComponent<NetworkingManager>();
+            UnetTransport unetTransport = NetManObject.AddComponent<UnetTransport>();
+            m_NetMan.NetworkConfig = new Configuration.NetworkConfig();
+            m_NetMan.NetworkConfig.CreatePlayerPrefab = false;
+            m_NetMan.NetworkConfig.AllowRuntimeSceneChanges = true;
+            m_NetMan.NetworkConfig.EnableSceneManagement = false;
+            unetTransport.ConnectAddress = "127.0.0.1";
+            unetTransport.ConnectPort = 7777;
+            unetTransport.ServerListenPort = 7777;
+            unetTransport.MessageBufferSize = 65535;
+            unetTransport.MaxConnections = 100;
+            unetTransport.MessageSendMode = UnetTransport.SendMode.Immediately;
+            m_NetMan.NetworkConfig.NetworkTransport = unetTransport;
+
+            var CurrentActiveScene = SceneManager.GetActiveScene();
+            var InstantiatedNetworkingManager = false;
+            var TestsAreComplete = false;
+            var TestsAreValidated = false;
+            var MaximumTimeTaken = 0.0f;
+
+            if (CurrentActiveScene != null)
+            {
+                //Add our test scene name
+                NetworkSceneManager.AddRuntimeSceneName(CurrentActiveScene.name, 0);
+
+                //Create the player object that we will spawn as a host
+                GameObject playerObject = new GameObject("RpcTestObject");
+                NetworkedObject playerNetworkObject = playerObject.AddComponent<NetworkedObject>();
+                RpcPipelineTestComponent RpcPipelineTestComponent = playerObject.AddComponent<RpcPipelineTestComponent>();
+
+                if (NetworkingManager.Singleton != null)
+                {
+                    Debug.Log("Networking Manager Instantiated.");
+                    InstantiatedNetworkingManager = true;
+                    //Start as host mode as loopback only works in hostmode
+                    NetworkingManager.Singleton.StartHost();
+
+                    Debug.Log("Host Started.");
+
+                    if (RpcPipelineTestComponent != null)
+                    {
+                        //Enable the simple ping test
+                        RpcPipelineTestComponent.PingSelfEnabled = true;
+                        Debug.Log("Running RPC Queue Tests...");
+
+                        //We shouldn't (for sure) take longer than 30 seconds
+                        MaximumTimeTaken = Time.realtimeSinceStartup + 30.0f;
+
+                        //Wait for the rpc pipeline test to complete or
+                        while (!TestsAreComplete && MaximumTimeTaken > Time.realtimeSinceStartup)
+                        {
+                            //Wait for 100ms
+                            yield return new WaitForSeconds(0.1f);
+
+                            TestsAreComplete = RpcPipelineTestComponent.IsTestComplete();
+                        }
+
+                        TestsAreValidated = RpcPipelineTestComponent.ValidateUpdateStages();
+                        //Stop pinging
+                        RpcPipelineTestComponent.PingSelfEnabled = false;
+
+                        Debug.Log("RPC Queue Testing completed.");
+                    }
+                }
+            }
+
+            Assert.IsTrue(TestsAreComplete && TestsAreValidated && InstantiatedNetworkingManager && MaximumTimeTaken > Time.realtimeSinceStartup);
+            // Use the Assert class to test conditions.
+            // Use yield to skip a frame.
+            yield return null;
+        }
+
+
+        [UnitySetUp]
+        public IEnumerator TearDown()
+        {
+            yield return new ExitPlayMode();
+        }
+    }
+}

com.unity.multiplayer.mlapi/Tests/Runtime/RpcPipelineTestComponent.cs

@@ -0,0 +1,176 @@
+using System.Collections.Generic;
+using UnityEngine;
+using MLAPI;
+using MLAPI.Messaging;
+
+namespace MLAPI.RuntimeTests
+{
+    public class RpcPipelineTestComponent : NetworkedBehaviour
+    {
+        /// <summary>
+        /// PingSelfEnabled
+        /// Allows the external RPCQueueTest to begin testing or stop it
+        /// </summary>
+        public bool PingSelfEnabled;
+
+        /// <summary>
+        /// MaxIterations
+        /// How many times will we iterate through the various NetworkUpdateStage values?
+        /// (defaults to 2)
+        /// </summary>
+        public int MaxIterations = 2;
+
+
+        // Start is called before the first frame update
+        void Start()
+        {
+            m_Serverparms.Send.UpdateStage = NetworkUpdateStage.Initialization;
+            m_Clientparms.Send.UpdateStage = NetworkUpdateStage.Update;
+        }
+
+        /// <summary>
+        /// IsTestComplete
+        /// Returns back whether the test has completed the total number of iterations
+        /// </summary>
+        /// <returns></returns>
+        public bool IsTestComplete()
+        {
+            if (m_Counter >= MaxIterations)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        private int m_Counter = 0;
+        private float m_NextUpdate = 0.0f;
+        private ServerRpcParams m_Serverparms;
+        private ClientRpcParams m_Clientparms;
+        private NetworkUpdateStage m_LastUpdateStage;
+
+        // Update is called once per frame
+        void Update()
+        {
+            if (NetworkingManager.Singleton.IsListening && PingSelfEnabled && m_NextUpdate < Time.realtimeSinceStartup)
+            {
+                if (NetworkingManager.Singleton.IsListening && PingSelfEnabled && m_NextUpdate < Time.realtimeSinceStartup)
+                {
+                    //As long as testing isn't completed, keep testing
+                    if (!IsTestComplete())
+                    {
+                        m_NextUpdate = Time.realtimeSinceStartup + 0.5f;
+                        m_LastUpdateStage = m_Serverparms.Send.UpdateStage;
+                        m_StagesSent.Add(m_LastUpdateStage);
+                        PingMySelfServerRPC(m_Serverparms);
+                        m_Clientparms.Send.UpdateStage = m_Serverparms.Send.UpdateStage;
+                        switch (m_Serverparms.Send.UpdateStage)
+                        {
+                            case NetworkUpdateStage.Initialization:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.EarlyUpdate;
+                                    break;
+                                }
+                            case NetworkUpdateStage.EarlyUpdate:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.FixedUpdate;
+                                    break;
+                                }
+                            case NetworkUpdateStage.FixedUpdate:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.PreUpdate;
+                                    break;
+                                }
+                            case NetworkUpdateStage.PreUpdate:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.Update;
+                                    break;
+                                }
+                            case NetworkUpdateStage.Update:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.PreLateUpdate;
+                                    break;
+                                }
+                            case NetworkUpdateStage.PreLateUpdate:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.PostLateUpdate;
+                                    break;
+                                }
+                            case NetworkUpdateStage.PostLateUpdate:
+                                {
+                                    m_Serverparms.Send.UpdateStage = NetworkUpdateStage.Initialization;
+
+                                    break;
+                                }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        private List<NetworkUpdateStage> m_ServerStagesReceived = new List<NetworkUpdateStage>();
+        private List<NetworkUpdateStage> m_ClientStagesReceived = new List<NetworkUpdateStage>();
+        private List<NetworkUpdateStage> m_StagesSent = new List<NetworkUpdateStage>();
+
+        /// <summary>
+        /// ValidateUpdateStages
+        /// Assures all update stages were in alginment with one another
+        /// </summary>
+        /// <returns>true or false</returns>
+        public bool ValidateUpdateStages()
+        {
+            var Validated = false;
+            if (m_ServerStagesReceived.Count == m_ClientStagesReceived.Count && m_ClientStagesReceived.Count == m_StagesSent.Count)
+            {
+                for (int i = 0; i < m_StagesSent.Count; i++)
+                {
+                    NetworkUpdateStage currentStage = m_StagesSent[i];
+                    if (m_ServerStagesReceived[i] != currentStage)
+                    {
+                        Debug.LogFormat("ServerRpc Update Stage ( {0} ) is not equal to the current update stage ( {1} ) ", m_ServerStagesReceived[i].ToString(), currentStage.ToString());
+                        return Validated;
+                    }
+                    if (m_ClientStagesReceived[i] != currentStage)
+                    {
+                        Debug.LogFormat("ClientRpc Update Stage ( {0} ) is not equal to the current update stage ( {1} ) ", m_ClientStagesReceived[i].ToString(), currentStage.ToString());
+                        return Validated;
+                    }
+                }
+                Validated = true;
+            }
+            return Validated;
+        }
+
+        /// <summary>
+        /// PingMySelfServerRPC
+        /// Server side RPC for testing
+        /// </summary>
+        /// <param name="parameters">server rpc parameters</param>
+        [ServerRpc]
+        void PingMySelfServerRPC(ServerRpcParams parameters)
+        {
+            Debug.Log("[HostClient][ServerRpc] invoked during the " + parameters.Receive.UpdateStage.ToString() + " stage.");
+            m_Clientparms.Send.UpdateStage = parameters.Receive.UpdateStage;
+            m_ServerStagesReceived.Add(m_Clientparms.Send.UpdateStage);
+            PingMySelfClientRpc(m_Clientparms);
+        }
+
+        /// <summary>
+        /// PingMySelfClientRpc
+        /// Client Side RPC called by PingMySelfServerRPC to validate both Client->Server and Server-Client pipeline is working
+        /// </summary>
+        /// <param name="parameters">client rpc parameters</param>
+        [ClientRpc]
+        void PingMySelfClientRpc(ClientRpcParams parameters)
+        {
+            m_ClientStagesReceived.Add(m_Clientparms.Send.UpdateStage);
+            Debug.Log("[HostServer][ClientRpc] invoked during the " + parameters.Receive.UpdateStage.ToString() + " stage. (previous output line should confirm this)");
+
+            //If we reached the last update state, then go ahead and increment our iteration counter
+            if (parameters.Receive.UpdateStage == NetworkUpdateStage.PostLateUpdate)
+            {
+                m_Counter++;
+            }
+        }
+    }
+}