Integration tests improvements:

1. Added dummy game ticker for future tests to reduce startup time of test. (no loading a map)
2. Re-organized tests a bit.

Content.IntegrationTests/Tests/ConnectTest.cs

@@ -0,0 +1,56 @@
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Robust.Server.Interfaces.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Network;
+using Robust.Shared.IoC;
+
+namespace Content.IntegrationTests.Tests
+{
+    [TestFixture]
+    public class ConnectTest : ContentIntegrationTest
+    {
+        [Test]
+        public async Task TestConnect()
+        {
+            var client = StartClient();
+            var server = StartServer();
+
+            await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
+
+            // Connect.
+
+            client.SetConnectTarget(server);
+
+            client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
+
+            // Run some ticks for the handshake to complete and such.
+
+            for (var i = 0; i < 10; i++)
+            {
+                server.RunTicks(1);
+                await server.WaitIdleAsync();
+                client.RunTicks(1);
+                await client.WaitIdleAsync();
+            }
+
+            await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
+
+            // Basic checks to ensure that they're connected and data got replicated.
+
+            var playerManager = server.ResolveDependency<IPlayerManager>();
+            Assert.That(playerManager.PlayerCount, Is.EqualTo(1));
+            Assert.That(playerManager.GetAllPlayers().First().Status, Is.EqualTo(SessionStatus.InGame));
+
+            var clEntityManager = client.ResolveDependency<IEntityManager>();
+            var svEntityManager = server.ResolveDependency<IEntityManager>();
+
+            var lastSvEntity = svEntityManager.GetEntities().Last();
+            var lastClEntity = clEntityManager.GetEntity(lastSvEntity.Uid);
+
+            Assert.That(lastClEntity.Transform.GridPosition, Is.EqualTo(lastSvEntity.Transform.GridPosition));
+        }
+    }
+}

Content.IntegrationTests/Tests/SaveLoadSaveTest.cs

@@ -0,0 +1,107 @@
+using System.IO;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Robust.Server.Interfaces.Maps;
+using Robust.Server.Interfaces.Timing;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.Interfaces.Resources;
+using Robust.Shared.Map;
+using Robust.Shared.Utility;
+
+namespace Content.IntegrationTests.Tests
+{
+    /// <summary>
+    ///     Tests that the
+    /// </summary>
+    [TestFixture]
+    public class SaveLoadSaveTest : ContentIntegrationTest
+    {
+        [Test]
+        public async Task SaveLoadSave()
+        {
+            var server = StartServer();
+            await server.WaitIdleAsync();
+            var mapLoader = server.ResolveDependency<IMapLoader>();
+            var mapManager = server.ResolveDependency<IMapManager>();
+            server.Post(() =>
+            {
+                mapLoader.SaveBlueprint(new GridId(2), "save load save 1.yml");
+                var mapId = mapManager.CreateMap();
+                var grid = mapLoader.LoadBlueprint(mapId, "save load save 1.yml");
+                mapLoader.SaveBlueprint(grid.Index, "save load save 2.yml");
+            });
+
+            await server.WaitIdleAsync();
+            var userData = server.ResolveDependency<IResourceManager>().UserData;
+
+            string one;
+            string two;
+
+            using (var stream = userData.Open(new ResourcePath("save load save 1.yml"), FileMode.Open))
+            using (var reader = new StreamReader(stream))
+            {
+                one = reader.ReadToEnd();
+            }
+
+            using (var stream = userData.Open(new ResourcePath("save load save 2.yml"), FileMode.Open))
+            using (var reader = new StreamReader(stream))
+            {
+                two = reader.ReadToEnd();
+            }
+
+            Assert.That(one, Is.EqualTo(two));
+        }
+
+        /// <summary>
+        ///     Loads the default map, runs it for 5 ticks, then assert that it did not change.
+        /// </summary>
+        [Test]
+        public async Task LoadSaveTicksSaveStationStation()
+        {
+            var server = StartServer();
+            await server.WaitIdleAsync();
+            var mapLoader = server.ResolveDependency<IMapLoader>();
+            var mapManager = server.ResolveDependency<IMapManager>();
+            var pauseMgr = server.ResolveDependency<IPauseManager>();
+
+            IMapGrid grid = default;
+
+            // Load stationstation.yml as uninitialized map, and save it to ensure it's up to date.
+            server.Post(() =>
+            {
+                var mapId = mapManager.CreateMap();
+                pauseMgr.AddUninitializedMap(mapId);
+                grid = mapLoader.LoadBlueprint(mapId, "Maps/stationstation.yml");
+                mapLoader.SaveBlueprint(grid.Index, "load save ticks save 1.yml");
+            });
+
+            // Run 5 ticks.
+            server.RunTicks(5);
+
+            server.Post(() =>
+            {
+                mapLoader.SaveBlueprint(grid.Index, "load save ticks save 2.yml");
+            });
+
+            await server.WaitIdleAsync();
+            var userData = server.ResolveDependency<IResourceManager>().UserData;
+
+            string one;
+            string two;
+
+            using (var stream = userData.Open(new ResourcePath("load save ticks save 1.yml"), FileMode.Open))
+            using (var reader = new StreamReader(stream))
+            {
+                one = reader.ReadToEnd();
+            }
+
+            using (var stream = userData.Open(new ResourcePath("load save ticks save 2.yml"), FileMode.Open))
+            using (var reader = new StreamReader(stream))
+            {
+                two = reader.ReadToEnd();
+            }
+
+            Assert.That(one, Is.EqualTo(two));
+        }
+    }
+}

Content.IntegrationTests/Tests/StartTest.cs

@@ -0,0 +1,46 @@
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Robust.Shared.Exceptions;
+
+namespace Content.IntegrationTests.Tests
+{
+    [TestFixture]
+    public class StartTest : ContentIntegrationTest
+    {
+        /// <summary>
+        ///     Test that the server starts.
+        /// </summary>
+        [Test]
+        public async Task TestServerStart()
+        {
+            var server = StartServer();
+            server.RunTicks(5);
+            await server.WaitIdleAsync();
+            Assert.That(server.IsAlive);
+            var runtimeLog = server.ResolveDependency<IRuntimeLog>();
+            Assert.That(runtimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged.");
+            server.Stop();
+            await server.WaitIdleAsync();
+            Assert.That(!server.IsAlive);
+        }
+
+        /// <summary>
+        ///     Test that the client starts.
+        /// </summary>
+        [Test]
+        public async Task TestClientStart()
+        {
+            var client = StartClient();
+            await client.WaitIdleAsync();
+            Assert.That(client.IsAlive);
+            client.RunTicks(5);
+            await client.WaitIdleAsync();
+            Assert.That(client.IsAlive);
+            var runtimeLog = client.ResolveDependency<IRuntimeLog>();
+            Assert.That(runtimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged.");
+            client.Stop();
+            await client.WaitIdleAsync();
+            Assert.That(!client.IsAlive);
+        }
+    }
+}