Add test for airlocks opening/closing and blocking entities (#1842)

* Add test for airlocks opening/closing and blocking entities

* Nullable fix classic

Content.IntegrationTests/ContentIntegrationTest.cs

@@ -1,13 +1,20 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Threading.Tasks;
 using Content.Client;
 using Content.Client.Interfaces.Parallax;
 using Content.Server;
 using Content.Server.Interfaces.GameTicking;
 using NUnit.Framework;
+using Robust.Server.Interfaces.Maps;
+using Robust.Server.Interfaces.Timing;
 using Robust.Shared.ContentPack;
+using Robust.Shared.Interfaces.Map;
 using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
 using Robust.UnitTesting;
 using EntryPoint = Content.Client.EntryPoint;
 
@@ -97,13 +104,72 @@ namespace Content.IntegrationTests
             return (client, server);
         }
 
+        protected async Task<IMapGrid> InitializeMap(ServerIntegrationInstance server, string mapPath)
+        {
+            await server.WaitIdleAsync();
+
+            var mapManager = server.ResolveDependency<IMapManager>();
+            var pauseManager = server.ResolveDependency<IPauseManager>();
+            var mapLoader = server.ResolveDependency<IMapLoader>();
+
+            IMapGrid grid = null;
+
+            server.Post(() =>
+            {
+                var mapId = mapManager.CreateMap();
+
+                pauseManager.AddUninitializedMap(mapId);
+
+                grid = mapLoader.LoadBlueprint(mapId, mapPath);
+
+                pauseManager.DoMapInitialize(mapId);
+            });
+
+            await server.WaitIdleAsync();
+
+            return grid;
+        }
+
+        protected async Task TryLoadEntities(IntegrationInstance instance, params string[] yamls)
+        {
+            await instance.WaitIdleAsync();
+
+            var prototypeManager = instance.ResolveDependency<IPrototypeManager>();
+
+            instance.Post(() =>
+            {
+                foreach (var yaml in yamls)
+                {
+                    using var reader = new StringReader(yaml);
+
+                    prototypeManager.LoadFromStream(reader);
+                }
+            });
+
+            await instance.WaitIdleAsync();
+        }
+
+        protected async Task WaitUntil(IntegrationInstance instance, Func<IntegrationInstance, bool> predicate, int tickStep = 10, int maxTicks = 600)
+        {
+            var ticksAwaited = 0;
+
+            while (!predicate(instance) && ticksAwaited < maxTicks)
+            {
+                await instance.WaitIdleAsync();
+                instance.RunTicks(tickStep);
+                ticksAwaited += tickStep;
+            }
+
+            await instance.WaitIdleAsync();
+        }
+
         private static async Task StartConnectedPairShared(ClientIntegrationInstance client, ServerIntegrationInstance server)
         {
             await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
 
             client.SetConnectTarget(server);
 
-            client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
+            client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null!, 0, null!));
 
             await RunTicksSync(client, server, 10);
         }

Content.IntegrationTests/Tests/Doors/AirlockTest.cs

@@ -0,0 +1,143 @@
+using System.IO;
+using System.Threading.Tasks;
+using Content.Server.GameObjects.Components.Doors;
+using Content.Shared.Physics;
+using NUnit.Framework;
+using Robust.Server.Console.Commands;
+using Robust.Shared.GameObjects.Components;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Prototypes;
+using static Content.Server.GameObjects.Components.Doors.ServerDoorComponent;
+
+namespace Content.IntegrationTests.Tests.Doors
+{
+    [TestFixture]
+    [TestOf(typeof(AirlockComponent))]
+    public class AirlockTest : ContentIntegrationTest
+    {
+        [Test]
+        public async Task OpenCloseDestroyTest()
+        {
+            var server = StartServerDummyTicker();
+
+            await server.WaitIdleAsync();
+
+            var mapManager = server.ResolveDependency<IMapManager>();
+            var entityManager = server.ResolveDependency<IEntityManager>();
+
+            IEntity airlock = null;
+            AirlockComponent airlockComponent = null;
+
+            server.Assert(() =>
+            {
+                mapManager.CreateNewMapEntity(MapId.Nullspace);
+
+                airlock = entityManager.SpawnEntity("Airlock", MapCoordinates.Nullspace);
+
+                Assert.True(airlock.TryGetComponent(out airlockComponent));
+                Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Closed));
+            });
+
+            await server.WaitIdleAsync();
+
+            server.Assert(() =>
+            {
+                airlockComponent.Open();
+                Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Opening));
+            });
+
+            await server.WaitIdleAsync();
+
+            await WaitUntil(server, _ => airlockComponent.State == DoorState.Open);
+
+            Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Open));
+
+            server.Assert(() =>
+            {
+                airlockComponent.Close();
+                Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Closing));
+            });
+
+            await WaitUntil(server, _ => airlockComponent.State == DoorState.Closed);
+
+            Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Closed));
+
+            server.Assert(() =>
+            {
+                Assert.DoesNotThrow(() =>
+                {
+                    airlock.Delete();
+                });
+            });
+
+            server.RunTicks(5);
+
+            await server.WaitIdleAsync();
+        }
+
+        [Test]
+        public async Task AirlockBlockTest()
+        {
+            var server = StartServer();
+
+            await server.WaitIdleAsync();
+
+            var mapManager = server.ResolveDependency<IMapManager>();
+            var entityManager = server.ResolveDependency<IEntityManager>();
+
+            IEntity human = null;
+            IEntity airlock = null;
+            TestController controller = null;
+            AirlockComponent airlockComponent = null;
+
+            var humanStartingX = -1;
+
+            server.Assert(() =>
+            {
+                var mapId = new MapId(1);
+                mapManager.CreateNewMapEntity(mapId);
+
+                var humanCoordinates = new MapCoordinates((humanStartingX, 0), mapId);
+                human = entityManager.SpawnEntity("HumanMob_Content", humanCoordinates);
+
+                airlock = entityManager.SpawnEntity("Airlock", new MapCoordinates((0, 0), mapId));
+
+                Assert.True(human.TryGetComponent(out ICollidableComponent collidable));
+
+                controller = collidable.EnsureController<TestController>();
+
+                Assert.True(airlock.TryGetComponent(out airlockComponent));
+                Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Closed));
+            });
+
+            await server.WaitIdleAsync();
+
+            // Push the human towards the airlock
+            controller.LinearVelocity = (0.5f, 0);
+
+            for (var i = 0; i < 240; i += 10)
+            {
+                // Keep the airlock awake so they collide
+                airlock.GetComponent<ICollidableComponent>().WakeBody();
+
+                // Ensure that it is still closed
+                Assert.That(airlockComponent.State, Is.EqualTo(DoorState.Closed));
+
+                await server.WaitRunTicks(10);
+                await server.WaitIdleAsync();
+            }
+
+            // Sanity check
+            Assert.That(human.Transform.MapPosition.X, Is.GreaterThan(humanStartingX));
+
+            // Blocked by the airlock
+            Assert.That(human.Transform.MapPosition.X, Is.Negative.Or.Zero);
+        }
+
+        private class TestController : VirtualController { }
+    }
+}