Change default test pooling options. (#18732)

Content.Benchmarks/DeviceNetworkingBenchmark.cs

@@ -58,7 +58,7 @@ public class DeviceNetworkingBenchmark
     public async Task SetupAsync()
     {
         ProgramShared.PathOffset = "../../../../";
-        _pair = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        _pair = await PoolManager.GetServerClient();
         var server = _pair.Pair.Server;
 
         await server.WaitPost(() =>

Content.IntegrationTests/PoolManager.cs

@@ -43,7 +43,7 @@ public static partial class PoolManager
 {
     public const string TestMap = "Empty";
 
-    private static readonly (string cvar, string value)[] ServerTestCvars =
+    private static readonly (string cvar, string value)[] TestCvars =
     {
         // @formatter:off
         (CCVars.DatabaseSynchronous.Name,     "true"),
@@ -60,6 +60,17 @@ public static partial class PoolManager
         (CCVars.EmergencyShuttleEnabled.Name, "false"),
         (CCVars.ProcgenPreload.Name,          "false"),
         (CCVars.WorldgenEnabled.Name,         "false"),
+        (CVars.ReplayClientRecordingEnabled.Name, "false"),
+        (CVars.ReplayServerRecordingEnabled.Name, "false"),
+        (CCVars.GameDummyTicker.Name, "true"),
+        (CCVars.GameLobbyEnabled.Name, "false"),
+        (CCVars.ConfigPresetDevelopment.Name, "false"),
+        (CCVars.AdminLogsEnabled.Name, "false"),
+
+        // This breaks some tests.
+        // TODO: Figure out which tests this breaks.
+        (CVars.NetBufferSize.Name, "0")
+
         // @formatter:on
     };
 
@@ -109,10 +120,10 @@ public static partial class PoolManager
                 .OnValueChanged(RTCVars.FailureLogLevel, value => logHandler.FailureLevel = value, true);
         };
 
-        SetupCVars(poolSettings, options);
+        SetDefaultCVars(options);
-
         var server = new RobustIntegrationTest.ServerIntegrationInstance(options);
         await server.WaitIdleAsync();
+        await SetupCVars(server, poolSettings);
         return (server, logHandler);
     }
 
@@ -206,42 +217,44 @@ public static partial class PoolManager
             });
         };
 
-        SetupCVars(poolSettings, options);
+        SetDefaultCVars(options);
-
         var client = new RobustIntegrationTest.ClientIntegrationInstance(options);
         await client.WaitIdleAsync();
+        await SetupCVars(client, poolSettings);
         return (client, logHandler);
     }
 
-    private static void SetupCVars(PoolSettings poolSettings, RobustIntegrationTest.IntegrationOptions options)
+    private static async Task  SetupCVars(RobustIntegrationTest.IntegrationInstance instance, PoolSettings settings)
     {
-        foreach (var (cvar, value) in ServerTestCvars)
+        var cfg = instance.ResolveDependency<IConfigurationManager>();
+        await instance.WaitPost(() =>
+        {
+            if (cfg.IsCVarRegistered(CCVars.GameDummyTicker.Name))
+                cfg.SetCVar(CCVars.GameDummyTicker, settings.UseDummyTicker);
+
+            if (cfg.IsCVarRegistered(CCVars.GameLobbyEnabled.Name))
+                cfg.SetCVar(CCVars.GameLobbyEnabled, settings.InLobby);
+
+            if (cfg.IsCVarRegistered(CVars.NetInterp.Name))
+                cfg.SetCVar(CVars.NetInterp, settings.DisableInterpolate);
+
+            if (cfg.IsCVarRegistered(CCVars.GameMap.Name))
+                cfg.SetCVar(CCVars.GameMap, settings.Map);
+
+            if (cfg.IsCVarRegistered(CCVars.AdminLogsEnabled.Name))
+                cfg.SetCVar(CCVars.AdminLogsEnabled, settings.AdminLogsEnabled);
+
+            if (cfg.IsCVarRegistered(CVars.NetInterp.Name))
+                cfg.SetCVar(CVars.NetInterp, !settings.DisableInterpolate);
+        });
+    }
+
+    private static void SetDefaultCVars(RobustIntegrationTest.IntegrationOptions options)
+    {
+        foreach (var (cvar, value) in TestCvars)
         {
             options.CVarOverrides[cvar] = value;
         }
-
-        if (poolSettings.DummyTicker)
-        {
-            options.CVarOverrides[CCVars.GameDummyTicker.Name] = "true";
-        }
-
-        options.CVarOverrides[CCVars.GameLobbyEnabled.Name] = poolSettings.InLobby.ToString();
-
-        if (poolSettings.DisableInterpolate)
-        {
-            options.CVarOverrides[CVars.NetInterp.Name] = "false";
-        }
-
-        if (poolSettings.Map != null)
-        {
-            options.CVarOverrides[CCVars.GameMap.Name] = poolSettings.Map;
-        }
-
-        options.CVarOverrides[CCVars.ConfigPresetDevelopment.Name] = "false";
-
-        // This breaks some tests.
-        // TODO: Figure out which tests this breaks.
-        options.CVarOverrides[CVars.NetBufferSize.Name] = "0";
     }
 
     /// <summary>
@@ -281,6 +294,11 @@ public static partial class PoolManager
                 await testOut.WriteLineAsync(
                     $"{nameof(GetServerClientPair)}: Creating pair, because settings of pool settings");
                 pair = await CreateServerClientPair(poolSettings, testOut);
+
+                // Newly created pairs should always be in a valid state.
+                await RunTicksSync(pair, 5);
+                await SyncTicks(pair, targetDelta: 1);
+                ValidateFastRecycle(pair, poolSettings);
             }
             else
             {
@@ -293,13 +311,12 @@ public static partial class PoolManager
                     await testOut.WriteLineAsync($"{nameof(GetServerClientPair)}: Suitable pair found");
                     var canSkip = pair.Settings.CanFastRecycle(poolSettings);
 
-                    var cCfg = pair.Client.ResolveDependency<IConfigurationManager>();
-                    cCfg.SetCVar(CCVars.NetInterp, !poolSettings.DisableInterpolate);
-
                     if (canSkip)
                     {
-                        ValidateFastRecycle(pair);
                         await testOut.WriteLineAsync($"{nameof(GetServerClientPair)}: Cleanup not needed, Skipping cleanup of pair");
+                        await SetupCVars(pair.Client, poolSettings);
+                        await SetupCVars(pair.Server, poolSettings);
+                        await RunTicksSync(pair, 1);
                     }
                     else
                     {
@@ -307,10 +324,9 @@ public static partial class PoolManager
                         await CleanPooledPair(poolSettings, pair, testOut);
                     }
 
-                    // Ensure client is 1 tick ahead of server? I don't think theres a real reason for why it should be
+                    await RunTicksSync(pair, 5);
-                    // 1 tick specifically, I am just ensuring consistency with CreateServerClientPair()
+                    await SyncTicks(pair, targetDelta: 1);
-                    if (!pair.Settings.NotConnected)
+                    ValidateFastRecycle(pair, poolSettings);
-                        await SyncTicks(pair, targetDelta: 1);
                 }
                 else
                 {
@@ -349,32 +365,38 @@ public static partial class PoolManager
         };
     }
 
-    private static void ValidateFastRecycle(Pair pair)
+    private static void ValidateFastRecycle(Pair pair, PoolSettings settings)
     {
-        if (pair.Settings.NoClient || pair.Settings.NoServer)
+        var cfg = pair.Server.ResolveDependency<IConfigurationManager>();
-            return;
+        Assert.That(cfg.GetCVar(CCVars.AdminLogsEnabled), Is.EqualTo(settings.AdminLogsEnabled));
+        Assert.That(cfg.GetCVar(CCVars.GameLobbyEnabled), Is.EqualTo(settings.InLobby));
+        Assert.That(cfg.GetCVar(CCVars.GameDummyTicker), Is.EqualTo(settings.UseDummyTicker));
+
+        var ticker = pair.Server.ResolveDependency<EntityManager>().System<GameTicker>();
+        Assert.That(ticker.DummyTicker, Is.EqualTo(settings.UseDummyTicker));
+
+        var expectPreRound = settings.InLobby | settings.DummyTicker;
+        var expectedLevel = expectPreRound ? GameRunLevel.PreRoundLobby : GameRunLevel.InRound;
+        Assert.That(ticker.RunLevel, Is.EqualTo(expectedLevel));
 
         var baseClient = pair.Client.ResolveDependency<IBaseClient>();
         var netMan = pair.Client.ResolveDependency<INetManager>();
-        Assert.That(netMan.IsConnected, Is.Not.EqualTo(pair.Settings.NotConnected));
+        Assert.That(netMan.IsConnected, Is.Not.EqualTo(!settings.ShouldBeConnected));
 
-        if (pair.Settings.NotConnected)
+        if (!settings.ShouldBeConnected)
             return;
 
         Assert.That(baseClient.RunLevel, Is.EqualTo(ClientRunLevel.InGame));
-
         var cPlayer = pair.Client.ResolveDependency<Robust.Client.Player.IPlayerManager>();
         var sPlayer = pair.Server.ResolveDependency<IPlayerManager>();
         Assert.That(sPlayer.Sessions.Count(), Is.EqualTo(1));
-        Assert.That(cPlayer.LocalPlayer?.Session?.UserId, Is.EqualTo(sPlayer.Sessions.Single().UserId));
+        Assert.That(cPlayer.LocalPlayer?.Session.UserId, Is.EqualTo(sPlayer.Sessions.Single().UserId));
 
-        var ticker = pair.Server.ResolveDependency<EntityManager>().System<GameTicker>();
+        if (ticker.DummyTicker)
-        Assert.That(ticker.DummyTicker, Is.EqualTo(pair.Settings.DummyTicker));
+            return;
 
-        var cfg = pair.Server.ResolveDependency<IConfigurationManager>();
-        Assert.That(cfg.GetCVar(CCVars.GameLobbyEnabled), Is.EqualTo(pair.Settings.InLobby));
         var status = ticker.PlayerGameStatuses[sPlayer.Sessions.Single().UserId];
-        var expected = pair.Settings.InLobby
+        var expected = settings.InLobby
             ? PlayerGameStatus.NotReadyToPlay
             : PlayerGameStatus.JoinedGame;
 
@@ -426,64 +448,59 @@ public static partial class PoolManager
         }
     }
 
-    private static async Task CleanPooledPair(PoolSettings poolSettings, Pair pair, TextWriter testOut)
+    private static async Task CleanPooledPair(PoolSettings settings, Pair pair, TextWriter testOut)
     {
+        pair.Settings = default!;
         var methodWatch = new Stopwatch();
         methodWatch.Start();
-        await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Setting CVar ");
+        await testOut.WriteLineAsync($"Recycling...");
+
         var configManager = pair.Server.ResolveDependency<IConfigurationManager>();
         var entityManager = pair.Server.ResolveDependency<IEntityManager>();
         var gameTicker = entityManager.System<GameTicker>();
-
-        configManager.SetCVar(CCVars.GameLobbyEnabled, poolSettings.InLobby);
-        configManager.SetCVar(CCVars.GameMap, TestMap);
-
         var cNetMgr = pair.Client.ResolveDependency<IClientNetManager>();
-        if (!cNetMgr.IsConnected)
+
+        await RunTicksSync(pair, 1);
+
+        // Disconnect the client if they are connected.
+        if (cNetMgr.IsConnected)
         {
-            await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Connecting client, and restarting server");
+            await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Disconnecting client.");
-            pair.Client.SetConnectTarget(pair.Server);
+            await pair.Client.WaitPost(() => cNetMgr.ClientDisconnect("Test pooling cleanup disconnect"));
-            await pair.Server.WaitPost(() =>
+            await RunTicksSync(pair, 1);
-            {
-                gameTicker.RestartRound();
-            });
-            await pair.Client.WaitPost(() =>
-            {
-                cNetMgr.ClientConnect(null!, 0, null!);
-            });
         }
-        await ReallyBeIdle(pair, 5);
+        Assert.That(cNetMgr.IsConnected, Is.False);
 
-        await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Disconnecting client, and restarting server");
+        // Move to pre-round lobby. Required to toggle dummy ticker on and off
-
+        if (gameTicker.RunLevel != GameRunLevel.PreRoundLobby)
-        await pair.Client.WaitPost(() =>
         {
-            cNetMgr.ClientDisconnect("Test pooling cleanup disconnect");
+            await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Restarting server.");
-        });
+            Assert.That(gameTicker.DummyTicker, Is.False);
+            configManager.SetCVar(CCVars.GameLobbyEnabled, true);
+            await pair.Server.WaitPost(() => gameTicker.RestartRound());
+            await RunTicksSync(pair, 1);
+        }
 
-        await ReallyBeIdle(pair, 5);
+        //Apply Cvars
+        await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Setting CVar ");
+        await SetupCVars(pair.Client, settings);
+        await SetupCVars(pair.Server, settings);
+        await RunTicksSync(pair, 1);
 
-        configManager.SetCVar(CCVars.GameMap, poolSettings.Map);
+        // Restart server.
         await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Restarting server again");
-
-        configManager.SetCVar(CCVars.GameMap, poolSettings.Map);
-        configManager.SetCVar(CCVars.GameDummyTicker, poolSettings.DummyTicker);
         await pair.Server.WaitPost(() => gameTicker.RestartRound());
+        await RunTicksSync(pair, 1);
 
-        if (!poolSettings.NotConnected)
+        // Connect client
+        if (settings.ShouldBeConnected)
         {
             await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Connecting client");
-            await ReallyBeIdle(pair);
             pair.Client.SetConnectTarget(pair.Server);
-            var netMgr = pair.Client.ResolveDependency<IClientNetManager>();
+            await pair.Client.WaitPost(() => cNetMgr.ClientConnect(null!, 0, null!));
-            await pair.Client.WaitPost(() =>
-            {
-                if (!netMgr.IsConnected)
-                {
-                    netMgr.ClientConnect(null!, 0, null!);
-                }
-            });
         }
+
+        await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Idling");
         await ReallyBeIdle(pair);
         await testOut.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Done recycling");
     }
@@ -533,7 +550,13 @@ we are just going to end this here to save a lot of time. This is the exception
             throw;
         }
 
-        if (!poolSettings.NotConnected)
+        if (!poolSettings.UseDummyTicker)
+        {
+            var gameTicker = pair.Server.ResolveDependency<IEntityManager>().System<GameTicker>();
+            await pair.Server.WaitPost(() => gameTicker.RestartRound());
+        }
+
+        if (poolSettings.ShouldBeConnected)
         {
             pair.Client.SetConnectTarget(pair.Server);
             await pair.Client.WaitPost(() =>
@@ -564,10 +587,7 @@ we are just going to end this here to save a lot of time. This is the exception
         var settings = pairTracker.Pair.Settings;
         var mapManager = server.ResolveDependency<IMapManager>();
         var tileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
-        var entityManager = server.ResolveDependency<IEntityManager>();
-        var xformSystem = entityManager.System<SharedTransformSystem>();
 
-        if (settings.NoServer) throw new Exception("Cannot setup test map without server");
         var mapData = new TestMapData();
         await server.WaitPost(() =>
         {
@@ -582,7 +602,7 @@ we are just going to end this here to save a lot of time. This is the exception
             mapData.MapCoords = new MapCoordinates(0, 0, mapData.MapId);
             mapData.Tile = mapData.MapGrid.GetAllTiles().First();
         });
-        if (!settings.Disconnected)
+        if (settings.ShouldBeConnected)
         {
             await RunTicksSync(pairTracker.Pair, 10);
         }
@@ -752,11 +772,6 @@ public sealed class PoolSettings
     /// </summary>
     public bool MustBeNew => Fresh || NoLoadContent || NoLoadTestPrototypes;
 
-    /// <summary>
-    /// If the given pair must not be connected
-    /// </summary>
-    public bool NotConnected => NoClient || NoServer || Disconnected;
-
     /// <summary>
     /// Set to true if the test will ruin the server/client pair.
     /// </summary>
@@ -768,19 +783,33 @@ public sealed class PoolSettings
     public bool Fresh { get; init; }
 
     /// <summary>
-    /// Set to true if the given server should be using a dummy ticker.
+    /// Set to true if the given server should be using a dummy ticker. Ignored if <see cref="InLobby"/> is true.
     /// </summary>
-    public bool DummyTicker { get; init; }
+    public bool DummyTicker { get; init; } = true;
+
+    public bool UseDummyTicker => !InLobby && DummyTicker;
 
     /// <summary>
-    /// Set to true if the given server/client pair should be disconnected from each other.
+    /// If true, this enables the creation of admin logs during the test.
     /// </summary>
-    public bool Disconnected { get; init; }
+    public bool AdminLogsEnabled { get; init; }
+
+    /// <summary>
+    /// Set to true if the given server/client pair should be connected from each other.
+    /// Defaults to disconnected as it makes dirty recycling slightly faster.
+    /// If <see cref="InLobby"/> is true, this option is ignored.
+    /// </summary>
+    public bool Connected { get; init; }
+
+    public bool ShouldBeConnected => InLobby || Connected;
 
     /// <summary>
     /// Set to true if the given server/client pair should be in the lobby.
     /// If the pair is not in the lobby at the end of the test, this test must be marked as dirty.
     /// </summary>
+    /// <remarks>
+    /// If this is enabled, the value of <see cref="DummyTicker"/> is ignored.
+    /// </remarks>
     public bool InLobby { get; init; }
 
     /// <summary>
@@ -811,16 +840,6 @@ public sealed class PoolSettings
     /// </summary>
     public string Map { get; init; } = PoolManager.TestMap;
 
-    /// <summary>
-    /// Set to true if the test won't use the client (so we can skip cleaning it up)
-    /// </summary>
-    public bool NoClient { get; init; }
-
-    /// <summary>
-    /// Set to true if the test won't use the server (so we can skip cleaning it up)
-    /// </summary>
-    public bool NoServer { get; init; }
-
     /// <summary>
     /// Overrides the test name detection, and uses this in the test history instead
     /// </summary>
@@ -843,8 +862,8 @@ public sealed class PoolSettings
             return false;
 
         // Check that certain settings match.
-        return NotConnected == nextSettings.NotConnected
+        return !ShouldBeConnected == !nextSettings.ShouldBeConnected
-               && DummyTicker == nextSettings.DummyTicker
+               && UseDummyTicker == nextSettings.UseDummyTicker
                && Map == nextSettings.Map
                && InLobby == nextSettings.InLobby;
     }

Content.IntegrationTests/Tests/Access/AccessReaderTest.cs

@@ -15,7 +15,7 @@ namespace Content.IntegrationTests.Tests.Access
         [Test]
         public async Task TestProtoTags()
         {
-            await using var pair = await PoolManager.GetServerClient(new PoolSettings() { NoClient = true });
+            await using var pair = await PoolManager.GetServerClient();
             var server = pair.Pair.Server;
 
             var protoManager = server.ResolveDependency<IPrototypeManager>();
@@ -44,7 +44,7 @@ namespace Content.IntegrationTests.Tests.Access
         [Test]
         public async Task TestTags()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var entityManager = server.ResolveDependency<IEntityManager>();
 

Content.IntegrationTests/Tests/Administration/Logs/AddTests.cs

@@ -3,14 +3,12 @@ using System.Linq;
 using Content.Server.Administration.Logs;
 using Content.Server.Database;
 using Content.Server.GameTicking;
-using Content.Server.GameTicking.Commands;
 using Content.Shared.Administration.Logs;
-using Content.Shared.CCVar;
 using Content.Shared.Database;
 using Robust.Server.Player;
-using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
+using Robust.Shared.Utility;
 
 namespace Content.IntegrationTests.Tests.Administration.Logs;
 
@@ -18,14 +16,19 @@ namespace Content.IntegrationTests.Tests.Administration.Logs;
 [TestOf(typeof(AdminLogSystem))]
 public sealed class AddTests
 {
+    public static PoolSettings LogTestSettings = new()
+    {
+        AdminLogsEnabled = true,
+        DummyTicker = false,
+        Connected = true
+    };
+
     [Test]
     public async Task AddAndGetSingleLog()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
-
         var sEntities = server.ResolveDependency<IEntityManager>();
-        var sMaps = server.ResolveDependency<IMapManager>();
 
         var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
 
@@ -68,12 +71,11 @@ public sealed class AddTests
     [Test]
     public async Task AddAndGetUnformattedLog()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sDatabase = server.ResolveDependency<IServerDbManager>();
         var sEntities = server.ResolveDependency<IEntityManager>();
-        var sMaps = server.ResolveDependency<IMapManager>();
         var sSystems = server.ResolveDependency<IEntitySystemManager>();
 
         var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
@@ -135,12 +137,10 @@ public sealed class AddTests
     [TestCase(500)]
     public async Task BulkAddLogs(int amount)
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sEntities = server.ResolveDependency<IEntityManager>();
-        var sMaps = server.ResolveDependency<IMapManager>();
-
         var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -167,11 +167,10 @@ public sealed class AddTests
     [Test]
     public async Task AddPlayerSessionLog()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sPlayers = server.ResolveDependency<IPlayerManager>();
-        var sSystems = server.ResolveDependency<IEntitySystemManager>();
 
         var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
         Guid playerGuid = default;
@@ -204,7 +203,14 @@ public sealed class AddTests
     [Test]
     public async Task PreRoundAddAndGetSingle()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Dirty = true, InLobby = true });
+        var setting = new PoolSettings
+        {
+            Dirty = true,
+            InLobby = true,
+            AdminLogsEnabled = true
+        };
+
+        await using var pairTracker = await PoolManager.GetServerClient(setting);
         var server = pairTracker.Pair.Server;
 
         var sDatabase = server.ResolveDependency<IServerDbManager>();
@@ -264,12 +270,10 @@ public sealed class AddTests
     [Test]
     public async Task DuplicatePlayerDoesNotThrowTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sPlayers = server.ResolveDependency<IPlayerManager>();
-        var sSystems = server.ResolveDependency<IEntitySystemManager>();
-
         var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
 
         var guid = Guid.NewGuid();
@@ -303,7 +307,7 @@ public sealed class AddTests
     [Test]
     public async Task DuplicatePlayerIdDoesNotThrowTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sPlayers = server.ResolveDependency<IPlayerManager>();

Content.IntegrationTests/Tests/Administration/Logs/FilterTests.cs

@@ -14,7 +14,7 @@ public sealed class FilterTests
     [TestCase(DateOrder.Descending)]
     public async Task Date(DateOrder order)
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient(AddTests.LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sEntities = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Administration/Logs/QueryTests.cs

@@ -15,7 +15,7 @@ public sealed class QueryTests
     [Test]
     public async Task QuerySingleLog()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(AddTests.LogTestSettings);
         var server = pairTracker.Pair.Server;
 
         var sSystems = server.ResolveDependency<IEntitySystemManager>();

Content.IntegrationTests/Tests/Atmos/AlarmThresholdTest.cs

@@ -24,7 +24,7 @@ namespace Content.IntegrationTests.Tests.Atmos
         [Test]
         public async Task TestAlarmThreshold()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var prototypeManager = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/Atmos/ConstantsTest.cs

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests.Atmos
         [Test]
         public async Task TotalGasesTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var entityManager = server.ResolveDependency<IEntityManager>();
 

Content.IntegrationTests/Tests/Atmos/GasMixtureTest.cs

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests.Atmos
         [Test]
         public async Task TestMerge()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var atmosphereSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<AtmosphereSystem>();
@@ -69,7 +69,7 @@ namespace Content.IntegrationTests.Tests.Atmos
         [TestCase(Atmospherics.BreathPercentage)]
         public async Task RemoveRatio(float ratio)
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             await server.WaitAssertion(() =>

Content.IntegrationTests/Tests/Body/LegTest.cs

@@ -29,10 +29,7 @@ namespace Content.IntegrationTests.Tests.Body
         [Test]
         public async Task RemoveLegsFallTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             EntityUid human = default!;

Content.IntegrationTests/Tests/Body/LungTest.cs

@@ -53,10 +53,7 @@ namespace Content.IntegrationTests.Tests.Body
         public async Task AirConsistencyTest()
         {
             // --- Setup
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             await server.WaitIdleAsync();
@@ -141,10 +138,7 @@ namespace Content.IntegrationTests.Tests.Body
         [Test]
         public async Task NoSuffocationTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var mapManager = server.ResolveDependency<IMapManager>();

Content.IntegrationTests/Tests/Body/SaveLoadReparentTest.cs

@@ -24,10 +24,7 @@ public sealed class SaveLoadReparentTest
     [Test]
     public async Task Test()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var entities = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Buckle/BuckleTest.cs

@@ -49,8 +49,7 @@ namespace Content.IntegrationTests.Tests.Buckle
         [Test]
         public async Task BuckleUnbuckleCooldownRangeTest()
         {
-            await using var pairTracker =
+            await using var pairTracker = await PoolManager.GetServerClient();
-                await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -243,10 +242,7 @@ namespace Content.IntegrationTests.Tests.Buckle
         [Test]
         public async Task BuckledDyingDropItemsTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -339,10 +335,7 @@ namespace Content.IntegrationTests.Tests.Buckle
         [Test]
         public async Task ForceUnbuckleBuckleTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/CargoTest.cs

@@ -17,7 +17,7 @@ public sealed class CargoTest
     [Test]
     public async Task NoCargoOrderArbitrage()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings() { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -51,7 +51,7 @@ public sealed class CargoTest
     [Test]
     public async Task NoCargoBountyArbitageTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings() { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -92,7 +92,7 @@ public sealed class CargoTest
     [Test]
     public async Task NoStaticPriceAndStackPrice()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -168,8 +168,7 @@ public sealed class CargoTest
     [Test]
     public async Task StackPrice()
     {
-
+        await using var pairTracker = await PoolManager.GetServerClient();
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true } );
         var server = pairTracker.Pair.Server;
 
         var entManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Chemistry/SolutionSystemTests.cs

@@ -46,10 +46,7 @@ public sealed class SolutionSystemTests
     [Test]
     public async Task TryAddTwoNonReactiveReagent()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var entityManager = server.ResolveDependency<IEntityManager>();
@@ -93,10 +90,7 @@ public sealed class SolutionSystemTests
     [Test]
     public async Task TryAddTooMuchNonReactiveReagent()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -140,10 +134,7 @@ public sealed class SolutionSystemTests
     [Test]
     public async Task TryMixAndOverflowTooMuchReagent()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
 
@@ -198,10 +189,7 @@ public sealed class SolutionSystemTests
     [Test]
     public async Task TryMixAndOverflowTooBigOverflow()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var entityManager = server.ResolveDependency<IEntityManager>();
@@ -238,7 +226,7 @@ public sealed class SolutionSystemTests
     [Test]
     public async Task TestTemperatureCalculations()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
         var protoMan = server.ResolveDependency<IPrototypeManager>();
         const float temp = 100.0f;

Content.IntegrationTests/Tests/Chemistry/TryAllReactionsTest.cs

@@ -27,10 +27,7 @@ namespace Content.IntegrationTests.Tests.Chemistry
         [Test]
         public async Task TryAllTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var entityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Cleanup/EuiManagerTest.cs

@@ -13,7 +13,11 @@ public sealed class EuiManagerTest
         // Even though we are using the server EUI here, we actually want to see if the client EUIManager crashes
         for (var i = 0; i < 2; i++)
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Dirty = true });
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                Connected = true,
+                Dirty = true
+            });
             var server = pairTracker.Pair.Server;
 
             var sPlayerManager = server.ResolveDependency<IPlayerManager>();

Content.IntegrationTests/Tests/ClickableTest.cs

@@ -44,7 +44,7 @@ namespace Content.IntegrationTests.Tests
         [TestCase("ClickTestRotatingCornerInvisibleNoRot", 0.25f, 0.25f, DirSouthEastJustShy, 1, ExpectedResult = true)]
         public async Task<bool> Test(string prototype, float clickPosX, float clickPosY, double angle, float scale)
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
             EntityUid entity = default;

Content.IntegrationTests/Tests/Commands/PardonCommand.cs

@@ -15,7 +15,7 @@ namespace Content.IntegrationTests.Tests.Commands
         [Test]
         public async Task PardonTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/Commands/RejuvenateTest.cs

@@ -33,13 +33,9 @@ namespace Content.IntegrationTests.Tests.Commands
         [Test]
         public async Task RejuvenateDeadTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var entManager = server.ResolveDependency<IEntityManager>();
-            var mapManager = server.ResolveDependency<IMapManager>();
             var prototypeManager = server.ResolveDependency<IPrototypeManager>();
             var mobStateSystem = entManager.EntitySysManager.GetEntitySystem<MobStateSystem>();
             var damSystem = entManager.EntitySysManager.GetEntitySystem<DamageableSystem>();

Content.IntegrationTests/Tests/Commands/RestartRoundTest.cs

@@ -16,7 +16,11 @@ namespace Content.IntegrationTests.Tests.Commands
         [TestCase(false)]
         public async Task RestartRoundAfterStart(bool lobbyEnabled)
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings() { Dirty = true });
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                DummyTicker = false,
+                Dirty = true
+            });
             var server = pairTracker.Pair.Server;
 
             var configManager = server.ResolveDependency<IConfigurationManager>();

Content.IntegrationTests/Tests/Construction/ConstructionActionValid.cs

@@ -47,7 +47,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task ConstructionGraphSpawnPrototypeValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -87,7 +87,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task ConstructionGraphEdgeValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/Construction/ConstructionPrototypeTest.cs

@@ -21,7 +21,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task TestStartNodeValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var entMan = server.ResolveDependency<IEntityManager>();
@@ -53,7 +53,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task TestStartIsValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -71,7 +71,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task TestTargetIsValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -89,7 +89,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task DeconstructionIsValid()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var entMan = server.ResolveDependency<IEntityManager>();
@@ -120,7 +120,7 @@ namespace Content.IntegrationTests.Tests.Construction
         [Test]
         public async Task TestStartReachesValidTarget()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/ContainerOcclusionTest.cs

@@ -34,7 +34,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestA()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var s = pairTracker.Pair.Server;
             var c = pairTracker.Pair.Client;
 
@@ -74,7 +74,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestB()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var s = pairTracker.Pair.Server;
             var c = pairTracker.Pair.Client;
 
@@ -114,7 +114,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestAb()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var s = pairTracker.Pair.Server;
             var c = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/Damageable/DamageableTest.cs

@@ -73,10 +73,7 @@ namespace Content.IntegrationTests.Tests.Damageable
         [Test]
         public async Task TestDamageableComponents()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var sEntityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/DeleteInventoryTest.cs

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var testMap = await PoolManager.CreateTestMap(pairTracker);
             var entMgr = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Destructible/DestructibleDamageGroupTest.cs

@@ -18,10 +18,7 @@ namespace Content.IntegrationTests.Tests.Destructible
         [Test]
         public async Task AndTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Destructible/DestructibleDamageTypeTest.cs

@@ -15,10 +15,7 @@ namespace Content.IntegrationTests.Tests.Destructible
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Destructible/DestructibleDestructionTest.cs

@@ -14,10 +14,7 @@ namespace Content.IntegrationTests.Tests.Destructible
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Destructible/DestructibleThresholdActivationTest.cs

@@ -20,10 +20,7 @@ namespace Content.IntegrationTests.Tests.Destructible
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var sEntityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTest.cs

@@ -51,10 +51,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
         [Test]
         public async Task NetworkDeviceSendAndReceive()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var mapManager = server.ResolveDependency<IMapManager>();
@@ -114,10 +111,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
         [Test]
         public async Task WirelessNetworkDeviceSendAndReceive()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var testMap = await PoolManager.CreateTestMap(pairTracker);
             var coordinates = testMap.GridCoords;
@@ -202,10 +196,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
         [Test]
         public async Task WiredNetworkDeviceSendAndReceive()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var testMap = await PoolManager.CreateTestMap(pairTracker);
             var coordinates = testMap.GridCoords;

Content.IntegrationTests/Tests/Disposal/DisposalUnitTest.cs

@@ -147,10 +147,7 @@ namespace Content.IntegrationTests.Tests.Disposal
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/DoAfter/DoAfterServerTest.cs

@@ -32,7 +32,7 @@ namespace Content.IntegrationTests.Tests.DoAfter
         [Test]
         public async Task TestSerializable()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
             var refMan = server.ResolveDependency<IReflectionManager>();
@@ -59,10 +59,7 @@ namespace Content.IntegrationTests.Tests.DoAfter
         [Test]
         public async Task TestFinished()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 
@@ -92,10 +89,7 @@ namespace Content.IntegrationTests.Tests.DoAfter
         [Test]
         public async Task TestCancelled()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var entityManager = server.ResolveDependency<IEntityManager>();
             var timing = server.ResolveDependency<IGameTiming>();

Content.IntegrationTests/Tests/Doors/AirlockTest.cs

@@ -53,10 +53,7 @@ namespace Content.IntegrationTests.Tests.Doors
         [Test]
         public async Task OpenCloseDestroyTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -115,10 +112,7 @@ namespace Content.IntegrationTests.Tests.Doors
         [Test]
         public async Task AirlockBlockTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             await server.WaitIdleAsync();

Content.IntegrationTests/Tests/DummyIconTest.cs

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var client = pairTracker.Pair.Client;
             var prototypeManager = client.ResolveDependency<IPrototypeManager>();
             var resourceCache = client.ResolveDependency<IResourceCache>();

Content.IntegrationTests/Tests/EntityTest.cs

@@ -21,7 +21,7 @@ namespace Content.IntegrationTests.Tests
         {
             // This test dirties the pair as it simply deletes ALL entities when done. Overhead of restarting the round
             // is minimal relative to the rest of the test.
-            var settings = new PoolSettings {NoClient = true, Dirty = true};
+            var settings = new PoolSettings { Dirty = true };
             await using var pairTracker = await PoolManager.GetServerClient(settings);
             var server = pairTracker.Pair.Server;
 
@@ -77,7 +77,7 @@ namespace Content.IntegrationTests.Tests
         {
             // This test dirties the pair as it simply deletes ALL entities when done. Overhead of restarting the round
             // is minimal relative to the rest of the test.
-            var settings = new PoolSettings {NoClient = true, Dirty = true};
+            var settings = new PoolSettings { Dirty = true };
             await using var pairTracker = await PoolManager.GetServerClient(settings);
             var server = pairTracker.Pair.Server;
             var map = await PoolManager.CreateTestMap(pairTracker);
@@ -133,7 +133,7 @@ namespace Content.IntegrationTests.Tests
         {
             // This test dirties the pair as it simply deletes ALL entities when done. Overhead of restarting the round
             // is minimal relative to the rest of the test.
-            var settings = new PoolSettings {NoClient = false, Dirty = true};
+            var settings = new PoolSettings { Connected = true, Dirty = true };
             await using var pairTracker = await PoolManager.GetServerClient(settings);
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
@@ -223,7 +223,7 @@ namespace Content.IntegrationTests.Tests
                 "BiomeSelection", // Whaddya know, requires config.
             };
 
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var mapManager = server.ResolveDependency<IMapManager>();
@@ -320,7 +320,7 @@ namespace Content.IntegrationTests.Tests
                 "BiomeSelection", // Whaddya know, requires config.
             };
 
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var mapManager = server.ResolveDependency<IMapManager>();

Content.IntegrationTests/Tests/Fluids/FluidSpillTest.cs

@@ -30,7 +30,7 @@ public sealed class FluidSpill
     [Test]
     public async Task SpillCorner()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
         var mapManager = server.ResolveDependency<IMapManager>();
         var entityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Fluids/PuddleTest.cs

@@ -16,7 +16,7 @@ namespace Content.IntegrationTests.Tests.Fluids
         [Test]
         public async Task TilePuddleTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);
@@ -42,7 +42,7 @@ namespace Content.IntegrationTests.Tests.Fluids
         [Test]
         public async Task SpaceNoPuddleTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/FollowerSystemTest.cs

@@ -14,7 +14,7 @@ public sealed class FollowerSystemTest
     [Test]
     public async Task FollowerMapDeleteTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new() { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/GameObjects/Components/ActionBlocking/HandCuffTest.cs

@@ -37,10 +37,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             EntityUid human;

Content.IntegrationTests/Tests/GameObjects/Components/Mobs/AlertsComponentTests.cs

@@ -16,7 +16,11 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Mobs
         [Test]
         public async Task AlertsTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                Connected = true,
+                DummyTicker = false
+            });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/GameRules/SecretStartsTest.cs

@@ -13,11 +13,7 @@ public sealed class SecretStartsTest
     [Test]
     public async Task TestSecretStarts()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings()
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Dirty = true });
-        {
-            NoClient = true,
-            Dirty = true,
-        });
 
         var server = pairTracker.Pair.Server;
         await server.WaitIdleAsync();

Content.IntegrationTests/Tests/GameRules/StartEndGameRulesTest.cs

@@ -15,10 +15,10 @@ public sealed class StartEndGameRulesTest
     [Test]
     public async Task TestAllConcurrent()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings()
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
         {
-            NoClient = true,
             Dirty = true,
+            DummyTicker = false
         });
         var server = pairTracker.Pair.Server;
         await server.WaitIdleAsync();

Content.IntegrationTests/Tests/Gravity/WeightlessStatusTests.cs

@@ -33,10 +33,7 @@ namespace Content.IntegrationTests.Tests.Gravity
         [Test]
         public async Task WeightlessStatusTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var entityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/GravityGridTest.cs

@@ -30,10 +30,7 @@ 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();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Guidebook/GuideEntryPrototypeTests.cs

@@ -15,7 +15,7 @@ public sealed class GuideEntryPrototypeTests
     [Test]
     public async Task ValidatePrototypeContents()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
         var client = pairTracker.Pair.Client;
         await client.WaitIdleAsync();
         var protoMan = client.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/Hands/HandTests.cs

@@ -13,7 +13,11 @@ public sealed class HandTests
     [Test]
     public async Task TestPickupDrop()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Connected = true,
+            DummyTicker = false
+        });
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/HumanInventoryUniformSlotsTest.cs

@@ -55,7 +55,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var testMap = await PoolManager.CreateTestMap(pairTracker);
             var coordinates = testMap.GridCoords;

Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs

@@ -39,10 +39,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
         [Test]
         public async Task InteractionTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();
@@ -112,10 +109,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
         [Test]
         public async Task InteractionObstructionTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();
@@ -186,7 +180,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
         [Test]
         public async Task InteractionInRangeTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();
@@ -256,7 +250,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
         [Test]
         public async Task InteractionOutOfRangeTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();
@@ -325,7 +319,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
         [Test]
         public async Task InsideContainerInteractionBlockTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Interaction/InRangeUnobstructed.cs

@@ -26,7 +26,7 @@ namespace Content.IntegrationTests.Tests.Interaction
         [Test]
         public async Task EntityEntityTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Interaction/InteractionTest.cs

@@ -140,7 +140,7 @@ public abstract partial class InteractionTest
     [SetUp]
     public virtual async Task Setup()
     {
-        PairTracker = await PoolManager.GetServerClient();
+        PairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
 
         // server dependencies
         SEntMan = Server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/InventoryHelpersTest.cs

@@ -41,7 +41,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task SpawnItemInSlotTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var sEntities = server.ResolveDependency<IEntityManager>();
@@ -87,7 +87,9 @@ namespace Content.IntegrationTests.Tests
                     ID: "InventoryIDCardDummy"
                 });
 #pragma warning restore NUnit2045
+                sEntities.DeleteEntity(human);
             });
+
             await pairTracker.CleanReturnAsync();
         }
     }

Content.IntegrationTests/Tests/Lobby/ServerReloginTest.cs

@@ -10,7 +10,11 @@ public sealed class ServerReloginTest
     [Test]
     public async Task Relogin()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Connected = true,
+            DummyTicker = false
+        });
         var server = pairTracker.Pair.Server;
         var client = pairTracker.Pair.Client;
         var originalMaxPlayers = 0;

Content.IntegrationTests/Tests/LogErrorTest.cs

@@ -12,7 +12,7 @@ public sealed class LogErrorTest
     [Test]
     public async Task TestLogErrorCausesTestFailure()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
         var server = pairTracker.Pair.Server;
         var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/MachineBoardTest.cs

@@ -31,7 +31,7 @@ public sealed class MachineBoardTest
     [Test]
     public async Task TestMachineBoardHasValidMachine()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -70,7 +70,7 @@ public sealed class MachineBoardTest
     [Test]
     public async Task TestComputerBoardHasValidComputer()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var protoMan = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/MaterialArbitrageTest.cs

@@ -30,7 +30,7 @@ public sealed class MaterialArbitrageTest
     [Test]
     public async Task NoMaterialArbitrage()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Materials/MaterialTests.cs

@@ -20,7 +20,7 @@ namespace Content.IntegrationTests.Tests.Materials
         [Test]
         public async Task MaterialPrototypeSpawnsStackMaterial()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 

Content.IntegrationTests/Tests/Minds/GhostRoleTests.cs

@@ -30,7 +30,11 @@ public sealed class GhostRoleTests
     [Test]
     public async Task TakeRoleAndReturn()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true
+        });
         var server = pairTracker.Pair.Server;
         var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/Minds/MindTests.Helpers.cs

@@ -25,7 +25,11 @@ public sealed partial class MindTests
     /// </remarks>
     private static async Task<PairTracker> SetupPair()
     {
-        var pairTracker = await PoolManager.GetServerClient();
+        var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        {
+            DummyTicker = false,
+            Connected = true
+        });
         var pair = pairTracker.Pair;
 
         var entMan = pair.Server.ResolveDependency<IServerEntityManager>();

Content.IntegrationTests/Tests/Minds/MindTests.cs

@@ -53,7 +53,7 @@ public sealed partial class MindTests
     [Test]
     public async Task TestCreateAndTransferMindToNewEntity()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -79,7 +79,7 @@ public sealed partial class MindTests
     [Test]
     public async Task TestReplaceMind()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -110,7 +110,7 @@ public sealed partial class MindTests
     [Test]
     public async Task TestEntityDeadWhenGibbed()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -164,7 +164,7 @@ public sealed partial class MindTests
     [Test]
     public async Task TestMindTransfersToOtherEntity()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -198,7 +198,11 @@ public sealed partial class MindTests
     [Test]
     public async Task TestOwningPlayerCanBeChanged()
     {
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        {
+            Connected = true,
+            DummyTicker = false
+        });
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -251,7 +255,7 @@ public sealed partial class MindTests
     [Test]
     public async Task TestAddRemoveHasRoles()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -320,7 +324,7 @@ public sealed partial class MindTests
     public async Task TestPlayerCanGhost()
     {
         // Client is needed to spawn session
-        await using var pairTracker = await PoolManager.GetServerClient();
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
@@ -396,16 +400,17 @@ public sealed partial class MindTests
     [Test]
     public async Task TestGhostDoesNotInfiniteLoop()
     {
-        // Client is needed to spawn session
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
-        await using var pairTracker = await PoolManager.GetServerClient();
+        {
+            DummyTicker = false,
+            Connected = true
+        });
         var server = pairTracker.Pair.Server;
 
         var entMan = server.ResolveDependency<IServerEntityManager>();
         var playerMan = server.ResolveDependency<IPlayerManager>();
         var serverConsole = server.ResolveDependency<IServerConsoleHost>();
 
-        var mindSystem = entMan.EntitySysManager.GetEntitySystem<MindSystem>();
-
         //EntityUid entity = default!;
         EntityUid mouse = default!;
         EntityUid ghost = default!;

Content.IntegrationTests/Tests/NPC/NPCTest.cs

@@ -12,7 +12,7 @@ public sealed class NPCTest
     [Test]
     public async Task CompoundRecursion()
     {
-        var pool = await PoolManager.GetServerClient(new PoolSettings() { NoClient = true });
+        var pool = await PoolManager.GetServerClient();
         var server = pool.Pair.Server;
 
         await server.WaitIdleAsync();

Content.IntegrationTests/Tests/Networking/ConnectTest.cs

@@ -1,37 +0,0 @@
-using System.Linq;
-using Robust.Server.Player;
-using Robust.Shared.Enums;
-using Robust.Shared.GameObjects;
-
-namespace Content.IntegrationTests.Tests.Networking
-{
-    [TestFixture]
-    public sealed class ConnectTest
-    {
-        [Test]
-        public async Task TestConnect()
-        {
-            await using var pairTracker = await PoolManager.GetServerClient();
-            var server = pairTracker.Pair.Server;
-            var client = pairTracker.Pair.Client;
-
-            // Basic checks to ensure that they're connected and data got replicated.
-
-            var playerManager = server.ResolveDependency<IPlayerManager>();
-#pragma warning disable NUnit2045 // Interdependent assertions.
-            Assert.That(playerManager.PlayerCount, Is.EqualTo(1));
-            Assert.That(playerManager.Sessions.First().Status, Is.EqualTo(SessionStatus.InGame));
-#pragma warning restore NUnit2045
-
-            var clEntityManager = client.ResolveDependency<IEntityManager>();
-            var svEntityManager = server.ResolveDependency<IEntityManager>();
-
-            var lastSvEntity = svEntityManager.GetEntities().Last();
-
-            Assert.That(clEntityManager.GetComponent<TransformComponent>(lastSvEntity).Coordinates,
-                Is.EqualTo(svEntityManager.GetComponent<TransformComponent>(lastSvEntity).Coordinates));
-
-            await pairTracker.CleanReturnAsync();
-        }
-    }
-}

Content.IntegrationTests/Tests/Networking/NetworkIdsMatchTest.cs

@@ -8,7 +8,7 @@ namespace Content.IntegrationTests.Tests.Networking
         [Test]
         public async Task TestConnect()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/Networking/ReconnectTest.cs

@@ -9,7 +9,7 @@ namespace Content.IntegrationTests.Tests.Networking
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
 

Content.IntegrationTests/Tests/Networking/SimplePredictReconcileTest.cs

@@ -31,7 +31,7 @@ namespace Content.IntegrationTests.Tests.Networking
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new() { DummyTicker = true });
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Connected = true });
             var server = pairTracker.Pair.Server;
             var client = pairTracker.Pair.Client;
 
@@ -43,6 +43,7 @@ namespace Content.IntegrationTests.Tests.Networking
             var cGameStateManager = client.ResolveDependency<IClientGameStateManager>();
             var cfg = client.ResolveDependency<IConfigurationManager>();
             var log = cfg.GetCVar(CVars.NetLogging);
+            Assert.That(cfg.GetCVar(CVars.NetInterp), Is.True);
 
             EntityUid serverEnt = default;
             PredictionTestComponent serverComponent = default!;

Content.IntegrationTests/Tests/PostMapInitTest.cs

@@ -68,7 +68,7 @@ namespace Content.IntegrationTests.Tests
         [Test, TestCaseSource(nameof(Grids))]
         public async Task GridsLoadableTest(string mapFile)
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var entManager = server.ResolveDependency<IEntityManager>();
@@ -109,7 +109,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task NoSavedPostMapInitTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var resourceManager = server.ResolveDependency<IResourceManager>();
@@ -151,7 +151,7 @@ namespace Content.IntegrationTests.Tests
         [Test, TestCaseSource(nameof(GameMaps))]
         public async Task GameMapsLoadableTest(string mapProto)
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var mapManager = server.ResolveDependency<IMapManager>();
@@ -283,7 +283,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task AllMapsTested()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings {NoClient = true});
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var protoMan = server.ResolveDependency<IPrototypeManager>();
 
@@ -302,7 +302,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task NonGameMapsLoadableTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();

Content.IntegrationTests/Tests/Power/PowerTest.cs

@@ -162,10 +162,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestSimpleSurplus()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -226,10 +223,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestSimpleDeficit()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -286,10 +280,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestSupplyRamp()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -376,10 +367,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestBatteryRamp()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -480,7 +468,7 @@ namespace Content.IntegrationTests.Tests.Power
         {
             // checks that batteries and supplies properly ramp down if the load is disconnected/disabled.
 
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -576,10 +564,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestSimpleBatteryChargeDeficit()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var gameTiming = server.ResolveDependency<IGameTiming>();
@@ -635,10 +620,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestFullBattery()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -715,10 +697,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestFullBatteryEfficiencyPassThrough()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -795,10 +774,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestFullBatteryEfficiencyDemandPassThrough()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -894,7 +870,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestSupplyPrioritized()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -992,10 +968,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestBatteriesProportional()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -1082,10 +1055,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestBatteryEngineCut()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -1169,10 +1139,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task TestTerminalNodeGroups()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -1237,10 +1204,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task ApcChargingTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();
@@ -1295,10 +1259,7 @@ namespace Content.IntegrationTests.Tests.Power
         [Test]
         public async Task ApcNetTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var entityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Procedural/DungeonTests.cs

@@ -12,7 +12,7 @@ public sealed class DungeonTests
     [Test]
     public async Task TestDungeonRoomPackBounds()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var protoManager = pairTracker.Pair.Server.ResolveDependency<IPrototypeManager>();
 
         await pairTracker.Pair.Server.WaitAssertion(() =>
@@ -62,7 +62,7 @@ public sealed class DungeonTests
     [Test]
     public async Task TestDungeonPresets()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var protoManager = pairTracker.Pair.Server.ResolveDependency<IPrototypeManager>();
 
         await pairTracker.Pair.Server.WaitAssertion(() =>

Content.IntegrationTests/Tests/PrototypeSaveTest.cs

@@ -41,7 +41,7 @@ public sealed class PrototypeSaveTest
     public async Task UninitializedSaveTest()
     {
         // Apparently SpawnTest fails to clean  up properly. Due to the similarities, I'll assume this also fails.
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var mapManager = server.ResolveDependency<IMapManager>();

Content.IntegrationTests/Tests/ResearchTest.cs

@@ -12,7 +12,7 @@ public sealed class ResearchTest
     [Test]
     public async Task DisciplineValidTierPrerequesitesTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var protoManager = server.ResolveDependency<IPrototypeManager>();
@@ -48,7 +48,7 @@ public sealed class ResearchTest
     [Test]
     public async Task AllTechPrintableTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var protoManager = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs

@@ -30,7 +30,11 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task ResettingEntitySystemResetTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                DummyTicker = false,
+                Connected = true
+            });
             var server = pairTracker.Pair.Server;
 
             var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();

Content.IntegrationTests/Tests/RestartRoundTest.cs

@@ -10,7 +10,11 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient();
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                DummyTicker = false,
+                Connected = true
+            });
             var server = pairTracker.Pair.Server;
             var sysManager = server.ResolveDependency<IEntitySystemManager>();
 

Content.IntegrationTests/Tests/RoundEndTest.cs

@@ -13,7 +13,11 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            {
+                DummyTicker = false,
+                Connected = true
+            });
 
             var server = pairTracker.Pair.Server;
 

Content.IntegrationTests/Tests/SaveLoadMapTest.cs

@@ -18,7 +18,7 @@ namespace Content.IntegrationTests.Tests
         {
             const string mapPath = @"/Maps/Test/TestMap.yml";
 
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var mapManager = server.ResolveDependency<IMapManager>();
             var sEntities = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/SaveLoadSaveTest.cs

@@ -21,7 +21,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task SaveLoadSave()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var entManager = server.ResolveDependency<IEntityManager>();
             var mapLoader = entManager.System<MapLoaderSystem>();
@@ -97,7 +97,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task LoadSaveTicksSaveBagel()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();
             var mapManager = server.ResolveDependency<IMapManager>();
@@ -179,7 +179,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task LoadTickLoadBagel()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();

Content.IntegrationTests/Tests/Serialization/SerializationTest.cs

@@ -17,7 +17,7 @@ public sealed class SerializationTest
     [Test]
     public async Task SerializeGenericEnums()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
         var seriMan = server.ResolveDependency<ISerializationManager>();
         var refMan = server.ResolveDependency<IReflectionManager>();

Content.IntegrationTests/Tests/Shuttle/DockTest.cs

@@ -21,7 +21,7 @@ public sealed class DockTest : ContentUnitTest
     [TestCaseSource(nameof(TestSource))]
     public async Task TestDockingConfig(Vector2 dock1Pos, Vector2 dock2Pos, Angle dock1Angle, Angle dock2Angle, bool result)
     {
-        await using var pair = await PoolManager.GetServerClient(new PoolSettings() { NoClient = true });
+        await using var pair = await PoolManager.GetServerClient();
         var server = pair.Pair.Server;
 
         var map = await PoolManager.CreateTestMap(pair);

Content.IntegrationTests/Tests/ShuttleTest.cs

@@ -15,7 +15,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 

Content.IntegrationTests/Tests/StackTest.cs

@@ -11,7 +11,7 @@ public sealed class StackTest
     [Test]
     public async Task StackCorrectItemSize()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+        await using var pairTracker = await PoolManager.GetServerClient();
         var server = pairTracker.Pair.Server;
 
         var protoManager = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/StartTest.cs

@@ -11,7 +11,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestClientStart()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Disconnected = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var client = pairTracker.Pair.Client;
             Assert.That(client.IsAlive);
             await client.WaitRunTicks(5);

Content.IntegrationTests/Tests/Station/StationJobsTest.cs

@@ -74,10 +74,7 @@ public sealed class StationJobsTest
     [Test]
     public async Task AssignJobsTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var prototypeManager = server.ResolveDependency<IPrototypeManager>();
@@ -151,10 +148,7 @@ public sealed class StationJobsTest
     [Test]
     public async Task AdjustJobsTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var prototypeManager = server.ResolveDependency<IPrototypeManager>();
@@ -205,10 +199,7 @@ public sealed class StationJobsTest
     [Test]
     public async Task InvalidRoundstartJobsTest()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+        await using var pairTracker = await PoolManager.GetServerClient();
-        {
-            NoClient = true
-        });
         var server = pairTracker.Pair.Server;
 
         var prototypeManager = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/StorageTest.cs

@@ -20,7 +20,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task StorageSizeArbitrageTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoManager = server.ResolveDependency<IPrototypeManager>();
@@ -42,7 +42,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestStorageFillPrototypes()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoManager = server.ResolveDependency<IPrototypeManager>();
@@ -70,7 +70,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestSufficientSpaceForFill()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var protoMan = server.ResolveDependency<IPrototypeManager>();

Content.IntegrationTests/Tests/Tag/TagTest.cs

@@ -44,10 +44,7 @@ namespace Content.IntegrationTests.Tests.Tag
         [Test]
         public async Task TagComponentTest()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var sEntityManager = server.ResolveDependency<IEntityManager>();

Content.IntegrationTests/Tests/Toolshed/ToolshedTest.cs

@@ -16,7 +16,7 @@ public abstract class ToolshedTest : IInvocationContext
 {
     protected PairTracker PairTracker = default!;
 
-    protected virtual bool NoClient => true;
+    protected virtual bool Connected => false;
     protected virtual bool AssertOnUnexpectedError => true;
 
     protected RobustIntegrationTest.ServerIntegrationInstance Server = default!;
@@ -32,7 +32,7 @@ public abstract class ToolshedTest : IInvocationContext
         await PairTracker.CleanReturnAsync();
         await TearDown();
     }
-    
+
     protected virtual async Task TearDown()
     {
         Assert.IsEmpty(_expectedErrors);
@@ -42,10 +42,10 @@ public abstract class ToolshedTest : IInvocationContext
     [SetUp]
     public virtual async Task Setup()
     {
-        PairTracker = await PoolManager.GetServerClient(new PoolSettings {NoClient = NoClient});
+        PairTracker = await PoolManager.GetServerClient(new PoolSettings {Connected = Connected});
         Server = PairTracker.Pair.Server;
 
-        if (!NoClient)
+        if (Connected)
         {
             Client = PairTracker.Pair.Client;
             await Client.WaitIdleAsync();

Content.IntegrationTests/Tests/Utility/EntitySystemExtensionsTest.cs

@@ -32,10 +32,7 @@ namespace Content.IntegrationTests.Tests.Utility
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
+            await using var pairTracker = await PoolManager.GetServerClient();
-            {
-                NoClient = true
-            });
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Utility/EntityWhitelistTest.cs

@@ -58,7 +58,7 @@ namespace Content.IntegrationTests.Tests.Utility
         [Test]
         public async Task Test()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
 
             var testMap = await PoolManager.CreateTestMap(pairTracker);

Content.IntegrationTests/Tests/Utility/SandboxTest.cs

@@ -6,7 +6,7 @@ public sealed class SandboxTest
     [Test]
     public async Task Test()
     {
-        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoServer = true, Destructive = true });
+        await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { Destructive = true });
         var client = pairTracker.Pair.Client;
         await client.CheckSandboxed(typeof(Client.Entry.EntryPoint).Assembly);
         await pairTracker.CleanReturnAsync();

Content.IntegrationTests/Tests/VendingMachineRestockTest.cs

@@ -105,7 +105,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestAllRestocksAreAvailableToBuy()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 
@@ -176,7 +176,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestCompleteRestockProcess()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 
@@ -262,7 +262,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestRestockBreaksOpen()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 
@@ -326,7 +326,7 @@ namespace Content.IntegrationTests.Tests
         [Test]
         public async Task TestRestockInventoryBounds()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             await server.WaitIdleAsync();
 

Content.MapRenderer/Painters/MapPainter.cs

@@ -28,6 +28,8 @@ namespace Content.MapRenderer.Painters
 
             await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings
             {
+                DummyTicker = false,
+                Connected = true,
                 Fresh = true,
                 Map = map
             });

Content.MapRenderer/Program.cs

@@ -34,8 +34,8 @@ namespace Content.MapRenderer
             {
                 Console.WriteLine("Didn't specify any maps to paint! Loading the map list...");
 
-                await using var server = await PoolManager.GetServerClient();
+                await using var pairTracker = await PoolManager.GetServerClient();
-                var mapIds = server.Pair.Server
+                var mapIds = pairTracker.Pair.Server
                     .ResolveDependency<IPrototypeManager>()
                     .EnumeratePrototypes<GameMapPrototype>()
                     .Select(map => map.ID)
@@ -108,8 +108,8 @@ namespace Content.MapRenderer
                 Console.WriteLine("Retrieving map ids by map file names...");
 
                 Console.Write("Fetching map prototypes... ");
-                await using var server = await PoolManager.GetServerClient();
+                await using var pairTracker = await PoolManager.GetServerClient();
-                var mapPrototypes = server.Pair.Server
+                var mapPrototypes = pairTracker.Pair.Server
                     .ResolveDependency<IPrototypeManager>()
                     .EnumeratePrototypes<GameMapPrototype>()
                     .ToArray();

Content.Server/Database/ServerDbBase.cs

@@ -14,6 +14,7 @@ using Content.Shared.Preferences;
 using Microsoft.EntityFrameworkCore;
 using Robust.Shared.Enums;
 using Robust.Shared.Network;
+using Robust.Shared.Utility;
 
 namespace Content.Server.Database
 {
@@ -758,6 +759,7 @@ INSERT INTO player_round (players_id, rounds_id) VALUES ({players[player]}, {id}
 
         public async Task AddAdminLogs(List<AdminLog> logs)
         {
+            DebugTools.Assert(logs.All(x => x.RoundId > 0), "Adding logs with invalid round ids.");
             await using var db = await GetDb();
             db.DbContext.AdminLog.AddRange(logs);
             await db.DbContext.SaveChangesAsync();

Content.Server/GameTicking/GameTicker.RoundFlow.cs

@@ -2,7 +2,6 @@ using Content.Server.Announcements;
 using Content.Server.GameTicking.Events;
 using Content.Server.Ghost;
 using Content.Server.Maps;
-using Content.Server.Mind;
 using Content.Server.Players;
 using Content.Shared.GameTicking;
 using Content.Shared.Preferences;
@@ -181,6 +180,9 @@ namespace Content.Server.GameTicking
 
             _startingRound = true;
 
+            if (RoundId == 0)
+                IncrementRoundNumber();
+
             ReplayStartRound();
 
             DebugTools.Assert(RunLevel == GameRunLevel.PreRoundLobby);
@@ -500,7 +502,8 @@ namespace Content.Server.GameTicking
                 RoundLengthMetric.Inc(frameTime);
             }
 
-            if (RunLevel != GameRunLevel.PreRoundLobby ||
+            if (_roundStartTime == TimeSpan.Zero ||
+                RunLevel != GameRunLevel.PreRoundLobby ||
                 Paused ||
                 _roundStartTime - RoundPreloadTime > _gameTiming.CurTime ||
                 _roundStartCountdownHasNotStartedYetDueToNoPlayers)

Content.Server/GameTicking/GameTicker.cs

@@ -14,7 +14,6 @@ using Content.Server.Station.Systems;
 using Content.Shared.Chat;
 using Content.Shared.Damage;
 using Content.Shared.GameTicking;
-using Content.Shared.Ghost;
 using Content.Shared.Mobs.Systems;
 using Content.Shared.Roles;
 using Robust.Server;
@@ -41,6 +40,7 @@ namespace Content.Server.GameTicking
         [Dependency] private readonly MindSystem _mind = default!;
         [Dependency] private readonly MindTrackerSystem _mindTracker = default!;
         [Dependency] private readonly MobStateSystem _mobState = default!;
+        [Dependency] private readonly IAdminLogManager _adminLogs = default!;
 
         [ViewVariables] private bool _initialized;
         [ViewVariables] private bool _postInitialized;
@@ -79,7 +79,8 @@ namespace Content.Server.GameTicking
             DebugTools.Assert(!_postInitialized);
 
             // We restart the round now that entities are initialized and prototypes have been loaded.
-            RestartRound();
+            if (!DummyTicker)
+                RestartRound();
 
             _postInitialized = true;
         }
@@ -99,6 +100,8 @@ namespace Content.Server.GameTicking
 
         public override void Update(float frameTime)
         {
+            if (DummyTicker)
+                return;
             base.Update(frameTime);
             UpdateRoundFlow(frameTime);
         }

Content.YAMLLinter/Program.cs

@@ -50,7 +50,7 @@ namespace Content.YAMLLinter
         private static async Task<(Dictionary<string, HashSet<ErrorNode>> YamlErrors, List<string> FieldErrors)>
             ValidateClient()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { DummyTicker = true, Disconnected = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var client = pairTracker.Pair.Client;
             var result = await ValidateInstance(client);
             await pairTracker.CleanReturnAsync();
@@ -60,7 +60,7 @@ namespace Content.YAMLLinter
         private static async Task<(Dictionary<string, HashSet<ErrorNode>> YamlErrors, List<string> FieldErrors)>
             ValidateServer()
         {
-            await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings { DummyTicker = true, NoClient = true });
+            await using var pairTracker = await PoolManager.GetServerClient();
             var server = pairTracker.Pair.Server;
             var result = await ValidateInstance(server);
             await pairTracker.CleanReturnAsync();