Prevent round end test from leaking (#9342)

Content.IntegrationTests/PoolManager.cs

@@ -15,6 +15,8 @@ using Content.Shared.Maps;
 using NUnit.Framework;
 using Robust.Client;
 using Robust.Server;
+using Robust.Server.GameStates;
+using Robust.Server.Player;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Exceptions;
@@ -212,11 +214,13 @@ public static class PoolManager
         await GetServerClientPair(poolSettings ?? new PoolSettings(), $"{testMethodFilePath}, {testMethodName}");
 
     private static async Task<PairTracker> GetServerClientPair(PoolSettings poolSettings, string testMethodName)
+    {
+        Pair pair = null;
+        try
         {
             var poolRetrieveTimeWatch = new Stopwatch();
             poolRetrieveTimeWatch.Start();
             await TestContext.Out.WriteLineAsync("Getting server/client");
-        Pair pair;
             if (poolSettings.MustBeNew)
             {
                 await TestContext.Out.WriteLineAsync($"Creating, because must be new pair");
@@ -247,10 +251,9 @@ public static class PoolManager
             }
 
             var poolRetrieveTime = poolRetrieveTimeWatch.Elapsed;
-        await TestContext.Out.WriteLineAsync($"Got server/client (id:{pair.PairId},uses:{pair.TestHistory.Count}) in {poolRetrieveTime.TotalMilliseconds} ms");
+            await TestContext.Out.WriteLineAsync(
+                $"Got server/client (id:{pair.PairId},uses:{pair.TestHistory.Count}) in {poolRetrieveTime.TotalMilliseconds} ms");
             pair.Settings = poolSettings;
-
-        TestContext.Out.WriteLine($"Test History|\n{string.Join('\n', pair.TestHistory)}\n|Test History End");
             pair.TestHistory.Add(testMethodName);
             var usageWatch = new Stopwatch();
             usageWatch.Start();
@@ -260,6 +263,14 @@ public static class PoolManager
                 UsageWatch = usageWatch
             };
         }
+        finally
+        {
+            if (pair != null)
+            {
+                TestContext.Out.WriteLine($"Test History|\n{string.Join('\n', pair.TestHistory)}\n|Test History End");
+            }
+        }
+    }
 
     private static Pair GrabOptimalPair(PoolSettings poolSettings)
     {
@@ -314,15 +325,17 @@ public static class PoolManager
             {
                 cNetMgr.ClientConnect(null!, 0, null!);
             });
-            await ReallyBeIdle(pair,11);
         }
+        await ReallyBeIdle(pair,11);
+
         await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Disconnecting client, and restarting server");
 
         await pair.Client.WaitPost(() =>
         {
             cNetMgr.ClientDisconnect("Test pooling cleanup disconnect");
         });
-        await ReallyBeIdle(pair, 5);
+
+        await ReallyBeIdle(pair, 10);
 
         if (!string.IsNullOrWhiteSpace(pair.Settings.ExtraPrototypes))
         {
@@ -413,10 +426,7 @@ public static class PoolManager
         var server = pairTracker.Pair.Server;
         var settings = pairTracker.Pair.Settings;
         if (settings.NoServer) throw new Exception("Cannot setup test map without server");
-        var mapData = new TestMapData
+        var mapData = new TestMapData();
-        {
-
-        };
         await server.WaitPost(() =>
         {
             var mapManager = IoCManager.Resolve<IMapManager>();

Content.IntegrationTests/Tests/RoundEndTest.cs

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Network;
 
 namespace Content.IntegrationTests.Tests
 {
@@ -17,10 +18,8 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings()
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
-            {
+
-                NoClient = true,
-            });
             var server = pairTracker.Pair.Server;
 
             var config = server.ResolveDependency<IConfigurationManager>();
@@ -32,14 +31,13 @@ namespace Content.IntegrationTests.Tests
 
             await server.WaitAssertion(() =>
             {
-                ticker.RestartRound();
                 config.SetCVar(CCVars.GameLobbyEnabled, true);
                 config.SetCVar(CCVars.EmergencyShuttleTransitTime, 1f);
                 config.SetCVar(CCVars.EmergencyShuttleDockTime, 1f);
 
-                roundEndSystem.DefaultCooldownDuration = TimeSpan.FromMilliseconds(250);
+                roundEndSystem.DefaultCooldownDuration = TimeSpan.FromMilliseconds(100);
-                roundEndSystem.DefaultCountdownDuration = TimeSpan.FromMilliseconds(500);
+                roundEndSystem.DefaultCountdownDuration = TimeSpan.FromMilliseconds(300);
-                roundEndSystem.DefaultRestartRoundDuration = TimeSpan.FromMilliseconds(250);
+                roundEndSystem.DefaultRestartRoundDuration = TimeSpan.FromMilliseconds(100);
             });
 
             await server.WaitAssertion(() =>
@@ -114,6 +112,20 @@ namespace Content.IntegrationTests.Tests
                 if (timeout.IsCompleted) throw new TimeoutException("Event took too long to trigger");
             }
 
+            // Need to clean self up
+            await server.WaitAssertion(() =>
+            {
+                config.SetCVar(CCVars.GameLobbyEnabled, false);
+                config.SetCVar(CCVars.EmergencyShuttleTransitTime, CCVars.EmergencyShuttleTransitTime.DefaultValue);
+                config.SetCVar(CCVars.EmergencyShuttleDockTime, CCVars.EmergencyShuttleDockTime.DefaultValue);
+
+                roundEndSystem.DefaultCooldownDuration = TimeSpan.FromSeconds(30);
+                roundEndSystem.DefaultCountdownDuration = TimeSpan.FromMinutes(4);
+                roundEndSystem.DefaultRestartRoundDuration = TimeSpan.FromMinutes(1);
+                EntitySystem.Get<GameTicker>().RestartRound();
+            });
+            await PoolManager.ReallyBeIdle(pairTracker.Pair, 10);
+
             await pairTracker.CleanReturnAsync();
         }
     }