chore: Enable U-PR bot [Up Port] (#4139)

* chore: Enable U-PR bot

* dotnet-fix

* test - fix

ValidateConnectionEventsAreEqual should check against the expectedEvent.ConnectionEvent.EventType and not the expectedEvent.SceneEvent.SceneEventType (the later throws an exception).

---------

Co-authored-by: Emma <emma.mcmillan@unity3d.com>

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

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);