Merge branch 'develop-3.x.x' into chore/unified-hybrid-tests-enabled-environment-var

develop-3.x.x now carries PR #4122 as a single squashed commit, so the four
unified files this branch also changes conflicted against their own squashed
history rather than against new work.

Conflict resolutions:
- .yamato/project.metafile: kept this branch's deletion of unified_test_filter.
  The squash reintroduced it; selection is the UNIFIED_TESTS environment
  variable plus NetcodeIntegrationTest.UseUnifiedTests now.
- .yamato/unified-tests.yml: kept this branch's version, which is the same job
  with the UNIFIED_TESTS variable and no --testfilter.
- .yamato/_triggers.yml: took develop-3.x.x (drops a stray blank line).
- NetcodeIntegrationTest.cs: took develop-3.x.x's TODO-UNIFIED tag rename.

Incoming: the SceneManagementSynchronizationTests rework that distinguishes
scene events from connection events and adjusts the m_UseCmbService path, which
is the CMB service test fix, plus the U-PR bot config.

Author: NoelStephensUnity

.pr_agent.toml

@@ -1,2 +1,9 @@
+# This is the configuration for the u-pr bot
+# https://github.cds.internal.unity3d.com/unity/u-pr
+# For configuration of this file:
+# https://developer.portal.internal.unity.com/catalog/default/component/u-pr/docs/configuration/automatic_runs/
+
 [github_app]
-pr_commands = []
+handle_pr_actions = ['opened', 'ready_for_review']  # PR events that auto-run pr_commands
+pr_commands       = ["/harness-review"]             # what runs on those events
+reviewer_commands = ["/harness-review"]             # what runs when @u-pr is added as reviewer

.yamato/_triggers.yml

@@ -91,7 +91,6 @@ pr_code_changes_checks:
     - .yamato/desktop-standalone-tests.yml#desktop_standalone_test_testproject_ubuntu_il2cpp_{{ pinnedTrunk }}
     - .yamato/cmb-service-standalone-tests.yml#cmb_service_standalone_test_testproject_ubuntu_il2cpp_{{ pinnedTrunk }}
     - .yamato/_run-all.yml#run_all_unified_tests
-
     # Run code coverage test (PRs use the pinned "safe" trunk)
     - .yamato/code-coverage.yml#code_coverage_project_test_testproject_ubuntu_{{ pinnedTrunk }}
   triggers:

com.unity.netcode.gameobjects/Tests/Runtime/TestHelpers/NetcodeIntegrationTest.cs

@@ -2722,7 +2722,7 @@ private GameObject SpawnObject(NetworkObject prefabNetworkObject, NetworkManager
             // N4E's rate managers reassign that singleton on every world update, so by the time a test body runs
             // it points at whichever world updated last - typically a client world - and the spawn is rejected with
             // "You can only spawn a ghost on a server or during prediction on a client."
-            // TODO-FixMe: NetCode.Netcode.Instance is a singleton and might cause issues assigning this.
+            // TODO-UNIFIED: NetCode.Netcode.Instance is a singleton and might cause issues assigning this.
             if (prefabNetworkObject.HasGhost)
             {
                 NetCode.Netcode.Instance.m_ActiveWorld = m_ServerNetworkManager.NetcodeWorld;

testproject/Assets/Tests/Runtime/NetworkSceneManager/SceneManagementSynchronizationTests.cs

@@ -6,6 +6,7 @@
 using Unity.Collections;
 using Unity.Netcode;
 using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
 using UnityEngine.TestTools;
 
 namespace TestProject.RuntimeTests
@@ -24,6 +25,7 @@ public SceneManagementSynchronizationTests(HostOrServer hostOrServer) : base(hos
 
         private struct ExpectedEvent
         {
+            public bool IsSceneEvent;
             public SceneEvent SceneEvent;
             public ConnectionEventData ConnectionEvent;
         }
@@ -51,13 +53,19 @@ private void AssertEventMatchesExpectedEvent<T>(Action<ExpectedEvent> predicate,
             if (m_ExpectedEventQueue.Count > 0)
             {
                 var expectedEvent = m_ExpectedEventQueue.Dequeue();
-                predicate(expectedEvent);
+                try
+                {
+                    predicate(expectedEvent);
+                }
+                catch (Exception failure)
+                {
+                    Debug.LogException(failure);
+                }
             }
             else
             {
                 Assert.Fail($"Received unexpected event at index {s_NumEventsProcessed}: {eventType}");
             }
-
             s_NumEventsProcessed++;
         }
 
@@ -100,42 +108,30 @@ public IEnumerator SynchronizationCallbacks_Authority()
             var expectedClientId = GetNonAuthorityNetworkManager().LocalClientId + 1;
 
             // Setup expected events
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new SceneEvent()
             {
-                SceneEvent = new SceneEvent()
-                {
-                    SceneEventType = SceneEventType.Synchronize,
-                    ClientId = expectedClientId
-                },
+                SceneEventType = SceneEventType.Synchronize,
+                ClientId = expectedClientId
             });
 
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new SceneEvent()
             {
-                SceneEvent = new SceneEvent()
-                {
-                    SceneEventType = SceneEventType.SynchronizeComplete,
-                    ClientId = expectedClientId,
-                },
+                SceneEventType = SceneEventType.SynchronizeComplete,
+                ClientId = expectedClientId,
             });
 
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new ConnectionEventData()
             {
-                ConnectionEvent = new ConnectionEventData()
-                {
-                    EventType = ConnectionEvent.ClientConnected,
-                    ClientId = expectedClientId,
-                }
+                EventType = ConnectionEvent.ClientConnected,
+                ClientId = expectedClientId,
             });
 
             if (m_UseHost)
             {
-                m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+                AddExpectedEvent(new ConnectionEventData()
                 {
-                    ConnectionEvent = new ConnectionEventData()
-                    {
-                        EventType = ConnectionEvent.PeerConnected,
-                        ClientId = expectedClientId,
-                    }
+                    EventType = ConnectionEvent.PeerConnected,
+                    ClientId = expectedClientId,
                 });
             }
 
@@ -158,31 +154,22 @@ public IEnumerator SynchronizationCallbacks_NonAuthority()
             var expectedPeerClientIds = m_UseHost ? new[] { authorityId, peerClientId } : new[] { peerClientId };
 
             // Setup expected events
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new SceneEvent()
             {
-                SceneEvent = new SceneEvent()
-                {
-                    SceneEventType = SceneEventType.Synchronize,
-                    ClientId = expectedClientId,
-                },
+                SceneEventType = SceneEventType.Synchronize,
+                ClientId = expectedClientId,
             });
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new ConnectionEventData()
             {
-                ConnectionEvent = new ConnectionEventData()
-                {
-                    EventType = ConnectionEvent.ClientConnected,
-                    ClientId = expectedClientId,
-                    PeerClientIds = new NativeArray<ulong>(expectedPeerClientIds.ToArray(), Allocator.Persistent),
-                }
+                EventType = ConnectionEvent.ClientConnected,
+                ClientId = expectedClientId,
+                PeerClientIds = new NativeArray<ulong>(expectedPeerClientIds.ToArray(), Allocator.Persistent),
             });
 
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            AddExpectedEvent(new SceneEvent()
             {
-                SceneEvent = new SceneEvent()
-                {
-                    SceneEventType = SceneEventType.SynchronizeComplete,
-                    ClientId = expectedClientId,
-                },
+                SceneEventType = SceneEventType.SynchronizeComplete,
+                ClientId = expectedClientId,
             });
 
             Assert.Null(m_ManagerToTest, "m_ManagerToTest should be null as we should be testing newly created client");
@@ -203,27 +190,22 @@ public IEnumerator LateJoiningClient_PeerCallbacks()
             var nonAuthority = GetNonAuthorityNetworkManager();
             var expectedClientId = nonAuthority.LocalClientId + 1;
             SetManagerToTest(nonAuthority);
+
             // Setup expected events
-            if (m_UseCmbService)
+            AddExpectedEvent(new ConnectionEventData()
             {
-                m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
-                {
-                    SceneEvent = new SceneEvent()
-                    {
-                        SceneEventType = SceneEventType.SynchronizeComplete,
-                        ClientId = expectedClientId,
-                    },
-                });
-            }
+                EventType = ConnectionEvent.PeerConnected,
+                ClientId = expectedClientId,
+            });
 
-            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            if (m_UseCmbService)
             {
-                ConnectionEvent = new ConnectionEventData()
+                AddExpectedEvent(new SceneEvent()
                 {
-                    EventType = ConnectionEvent.PeerConnected,
+                    SceneEventType = SceneEventType.SynchronizeComplete,
                     ClientId = expectedClientId,
-                }
-            });
+                });
+            }
 
             //////////////////////////////////////////
             // Testing event notifications
@@ -233,16 +215,34 @@ public IEnumerator LateJoiningClient_PeerCallbacks()
             Assert.IsEmpty(m_ExpectedEventQueue, "Not all expected callbacks were received");
         }
 
+        private void AddExpectedEvent(SceneEvent expectedEvent)
+        {
+            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            {
+                IsSceneEvent = true,
+                SceneEvent = expectedEvent,
+            });
+        }
+
+        private void AddExpectedEvent(ConnectionEventData expectedEvent)
+        {
+            m_ExpectedEventQueue.Enqueue(new ExpectedEvent()
+            {
+                IsSceneEvent = false,
+                ConnectionEvent = expectedEvent,
+            });
+        }
+
         private static void ValidateSceneEventsAreEqual(ExpectedEvent expectedEvent, SceneEvent sceneEvent)
         {
-            Assert.NotNull(expectedEvent.SceneEvent, $"Received unexpected scene event {sceneEvent.SceneEventType} at index {s_NumEventsProcessed}");
+            Assert.That(expectedEvent.IsSceneEvent, Is.True, $"Received unexpected scene event {sceneEvent.SceneEventType} at index {s_NumEventsProcessed}. Expected connection event: {expectedEvent.ConnectionEvent.EventType}");
             AssertField(expectedEvent.SceneEvent.SceneEventType, sceneEvent.SceneEventType, nameof(sceneEvent.SceneEventType), sceneEvent.SceneEventType);
             AssertField(expectedEvent.SceneEvent.ClientId, sceneEvent.ClientId, nameof(sceneEvent.ClientId), sceneEvent.SceneEventType);
         }
 
         private static void ValidateConnectionEventsAreEqual(ExpectedEvent expectedEvent, ConnectionEventData eventData)
         {
-            Assert.NotNull(expectedEvent.ConnectionEvent, $"Received unexpected connection event {eventData.EventType} at index {s_NumEventsProcessed}");
+            Assert.That(expectedEvent.IsSceneEvent, Is.False, $"Received unexpected connection event {eventData.EventType} at index {s_NumEventsProcessed}. Expected scene event: {expectedEvent.ConnectionEvent.EventType}");
             AssertField(expectedEvent.ConnectionEvent.EventType, eventData.EventType, nameof(eventData.EventType), eventData.EventType);
             AssertField(expectedEvent.ConnectionEvent.ClientId, eventData.ClientId, nameof(eventData.ClientId), eventData.EventType);