feat: increase hybrid prefab test coverage (#4172)

* test: run hybrid test cases over the unified transport

N4E worlds and UnifiedNetcodeTransport only start when at least one hybrid
prefab is registered. Player prefabs are never hybrid, so a UnifiedHost or
UnifiedServer test case that spawns nothing but players silently ran as plain
NGO. CreateServerAndClients now registers a UnifiedSessionPrefab when a hybrid
test case registered no hybrid prefab of its own.

* test: opt existing integration tests into hybrid prefab mode

Adds UnifiedHost/UnifiedServer fixtures and the UseUnifiedTests opt-in to 25
fixtures covering RPCs, NetworkVariables and collections, connection approval,
spawn/despawn, ownership, late-join synchronization and NGO parenting of
hybrid objects.

Ghosts spawn from a snapshot, later than NGO's spawn message, so tests that
read SpawnedObjects immediately after a spawn or a late join now wait with
WaitForSpawnedOnAllOrTimeOut. ComponentControllerTests' predicates were
missing a continue and threw instead of waiting.

RpcTests, RpcTypeSerializationTests and ClientApprovalDenied gain explicit
Host/Server fixture arguments: NUnit drops a bare [TestFixture] when the class
also has parameterized fixtures.

NetworkObjectDeserializationFailure is ignored for hybrid prefabs: removing a
prefab from one client's NetworkConfig does not unregister its ghost prefab,
which all worlds in the process share.

* test: run NetworkBehaviourUpdaterTests cases in one session per mode

The fixture was expanded into 36 [TestFixture]s (mode x client count x NetVar
combination), each starting its own session for both of its two test cases.
It now has one fixture per HostOrServer mode, and a single test that walks
the NetVar combinations and spawn counts in arrays, adding a client between
passes and despawning each case's objects before the next. Failure messages
name the case.

The 1 and 2 client passes now include a late-joined client, where every
case previously ran against a freshly started session.

* test: loop NetworkVariableCollectionsChangingTests over its collection types

The collection type only selects which helper component the prefab carries,
so it no longer needs its own fixture. Both prefabs are registered up front
and each test runs List then Dictionary in one session, despawning the
instance from its current authority between them. Failure messages name the
collection type. 10 fixtures become 5.

* style: comment verbosity pass

Author: NoelStephensUnity

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

@@ -12,10 +12,21 @@ namespace Unity.Netcode.RuntimeTests
     [TestFixture(HostOrServer.Host)]
     [TestFixture(HostOrServer.Server)]
     [TestFixture(HostOrServer.DAHost)]
+#if UNIFIED_NETCODE
+    [TestFixture(HostOrServer.UnifiedHost)]
+    [TestFixture(HostOrServer.UnifiedServer)]
+#endif
     internal class ComponentControllerTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 2;
 
+#if UNIFIED_NETCODE
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         private StringBuilder m_ErrorLog = new StringBuilder();
         private GameObject m_TestPrefab;
 
@@ -113,6 +124,7 @@ private bool AllComponentStatesMatch()
                 if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(m_AuthorityController.NetworkObjectId))
                 {
                     m_ErrorLog.AppendLine($"[Client-{networkManager.LocalClientId}] Does not have a spawned instance of {m_AuthorityController.name}!");
+                    continue;
                 }
                 var controller = networkManager.SpawnManager.SpawnedObjects[m_AuthorityController.NetworkObjectId].GetComponent<ComponentController>();
                 ControllerStateMatches(controller);
@@ -128,6 +140,7 @@ private bool AllComponentStatesAreCorrect(bool isEnabled)
                 if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(m_AuthorityController.NetworkObjectId))
                 {
                     m_ErrorLog.AppendLine($"[Client-{networkManager.LocalClientId}] Does not have a spawned instance of {m_AuthorityController.name}!");
+                    continue;
                 }
                 var controller = networkManager.SpawnManager.SpawnedObjects[m_AuthorityController.NetworkObjectId].GetComponent<ComponentController>();
                 for (int i = 0; i < controller.ValidComponents.Count; i++)

com.unity.netcode.gameobjects/Tests/Runtime/Connection/ClientApprovalDenied.cs

@@ -7,9 +7,23 @@
 
 namespace Unity.Netcode.RuntimeTests
 {
+    [TestFixture(HostOrServer.Host)]
+#if UNIFIED_NETCODE
+    [TestFixture(HostOrServer.UnifiedHost)]
+#endif
     internal class ClientApprovalDenied : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 2;
+
+        public ClientApprovalDenied(HostOrServer hostOrServer) : base(hostOrServer) { }
+
+#if UNIFIED_NETCODE
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         private bool m_ApproveConnection = true;
         private ulong m_PendingClientId = 0;
         private ulong m_DisconnectedClientId = 0;

com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApproval.cs

@@ -13,6 +13,12 @@ namespace Unity.Netcode.RuntimeTests
     [TestFixture(PlayerCreation.PrefabHash)]
     [TestFixture(PlayerCreation.NoPlayer)]
     [TestFixture(PlayerCreation.FailValidation)]
+#if UNIFIED_NETCODE
+    [TestFixture(PlayerCreation.Prefab, HostOrServer.UnifiedHost)]
+    [TestFixture(PlayerCreation.PrefabHash, HostOrServer.UnifiedHost)]
+    [TestFixture(PlayerCreation.NoPlayer, HostOrServer.UnifiedHost)]
+    [TestFixture(PlayerCreation.FailValidation, HostOrServer.UnifiedHost)]
+#endif
     internal class ConnectionApprovalTests : IntegrationTestWithApproximation
     {
         private const string k_InvalidToken = "Invalid validation token!";
@@ -36,6 +42,18 @@ public ConnectionApprovalTests(PlayerCreation playerCreation)
             m_PlayerCreation = playerCreation;
         }
 
+#if UNIFIED_NETCODE
+        public ConnectionApprovalTests(PlayerCreation playerCreation, HostOrServer hostOrServer) : base(hostOrServer)
+        {
+            m_PlayerCreation = playerCreation;
+        }
+
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         protected override int NumberOfClients => 1;
 
         private string m_ValidationToken;

com.unity.netcode.gameobjects/Tests/Runtime/Connection/ConnectionApprovalTimeoutTests.cs

@@ -9,6 +9,10 @@ namespace Unity.Netcode.RuntimeTests
 {
     [TestFixture(ApprovalTimedOutTypes.ServerDoesNotRespond)]
     [TestFixture(ApprovalTimedOutTypes.ClientDoesNotRequest)]
+#if UNIFIED_NETCODE
+    [TestFixture(ApprovalTimedOutTypes.ServerDoesNotRespond, HostOrServer.UnifiedHost)]
+    [TestFixture(ApprovalTimedOutTypes.ClientDoesNotRequest, HostOrServer.UnifiedHost)]
+#endif
     internal class ConnectionApprovalTimeoutTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 1;
@@ -26,6 +30,18 @@ public ConnectionApprovalTimeoutTests(ApprovalTimedOutTypes approvalFailureType)
             m_ApprovalFailureType = approvalFailureType;
         }
 
+#if UNIFIED_NETCODE
+        public ConnectionApprovalTimeoutTests(ApprovalTimedOutTypes approvalFailureType, HostOrServer hostOrServer) : base(hostOrServer)
+        {
+            m_ApprovalFailureType = approvalFailureType;
+        }
+
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         // Must be >= 5 since this is an int value and the test waits for timeout - 1 to try to verify it doesn't
         // time out early
         private const int k_TestTimeoutPeriod = 3;

com.unity.netcode.gameobjects/Tests/Runtime/Messaging/MessageReceiveAllocationTests.cs

@@ -23,10 +23,20 @@ public void NotMeRpc()
 
     [TestFixture(HostOrServer.Host)]
     [TestFixture(HostOrServer.DAHost)]
+#if UNIFIED_NETCODE
+    [TestFixture(HostOrServer.UnifiedHost)]
+#endif
     internal class MessageReceiveAllocationTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 1;
 
+#if UNIFIED_NETCODE
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         public MessageReceiveAllocationTests(HostOrServer hostOrServer) : base(hostOrServer) { }
 
         private GameObject m_Prefab;

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

@@ -8,10 +8,20 @@ namespace Unity.Netcode.RuntimeTests
 {
     [TestFixture(HostOrServer.Host)]
     [TestFixture(HostOrServer.DAHost)]
+#if UNIFIED_NETCODE
+    [TestFixture(HostOrServer.UnifiedHost)]
+#endif
     internal class NetworkBehaviourPrePostSpawnTests : NetcodeIntegrationTest
     {
         protected override int NumberOfClients => 0;
 
+#if UNIFIED_NETCODE
+        protected override bool UseUnifiedTests()
+        {
+            return true;
+        }
+#endif
+
         // TODO: [CmbServiceTests] Adapt to run with the service
         protected override bool UseCMBService()
         {