Add interaction tests (#15251)

Content.Client/Construction/ConstructionSystem.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Content.Shared.Construction;
 using Content.Shared.Construction.Prototypes;
 using Content.Shared.Examine;
@@ -151,33 +152,45 @@ namespace Content.Client.Construction
         /// Creates a construction ghost at the given location.
         /// </summary>
         public void SpawnGhost(ConstructionPrototype prototype, EntityCoordinates loc, Direction dir)
+            => TrySpawnGhost(prototype, loc, dir, out _);
+
+        /// <summary>
+        /// Creates a construction ghost at the given location.
+        /// </summary>
+        public bool TrySpawnGhost(
+            ConstructionPrototype prototype,
+            EntityCoordinates loc,
+            Direction dir,
+            [NotNullWhen(true)] out EntityUid? ghost)
         {
+            ghost = null;
             if (_playerManager.LocalPlayer?.ControlledEntity is not { } user ||
                 !user.IsValid())
             {
-                return;
+                return false;
             }
 
-            if (GhostPresent(loc)) return;
+            if (GhostPresent(loc))
+                return false;
 
             // This InRangeUnobstructed should probably be replaced with "is there something blocking us in that tile?"
             var predicate = GetPredicate(prototype.CanBuildInImpassable, loc.ToMap(EntityManager));
             if (!_interactionSystem.InRangeUnobstructed(user, loc, 20f, predicate: predicate))
-                return;
+                return false;
 
             foreach (var condition in prototype.Conditions)
             {
                 if (!condition.Condition(user, loc, dir))
-                    return;
+                    return false;
             }
 
-            var ghost = EntityManager.SpawnEntity("constructionghost", loc);
+            ghost = EntityManager.SpawnEntity("constructionghost", loc);
-            var comp = EntityManager.GetComponent<ConstructionGhostComponent>(ghost);
+            var comp = EntityManager.GetComponent<ConstructionGhostComponent>(ghost.Value);
             comp.Prototype = prototype;
             comp.GhostId = _nextId++;
-            EntityManager.GetComponent<TransformComponent>(ghost).LocalRotation = dir.ToAngle();
+            EntityManager.GetComponent<TransformComponent>(ghost.Value).LocalRotation = dir.ToAngle();
             _ghosts.Add(comp.GhostId, comp);
-            var sprite = EntityManager.GetComponent<SpriteComponent>(ghost);
+            var sprite = EntityManager.GetComponent<SpriteComponent>(ghost.Value);
             sprite.Color = new Color(48, 255, 48, 128);
 
             for (int i = 0; i < prototype.Layers.Count; i++)
@@ -189,7 +202,9 @@ namespace Content.Client.Construction
             }
 
             if (prototype.CanBuildInImpassable)
-                EnsureComp<WallMountComponent>(ghost).Arc = new(Math.Tau);
+                EnsureComp<WallMountComponent>(ghost.Value).Arc = new(Math.Tau);
+
+            return true;
         }
 
         /// <summary>
@@ -205,7 +220,7 @@ namespace Content.Client.Construction
             return false;
         }
 
-        private void TryStartConstruction(int ghostId)
+        public void TryStartConstruction(int ghostId)
         {
             var ghost = _ghosts[ghostId];
 

Content.Client/Examine/ExamineSystem.cs

@@ -21,7 +21,7 @@ using static Robust.Client.UserInterface.Controls.BoxContainer;
 namespace Content.Client.Examine
 {
     [UsedImplicitly]
-    internal sealed class ExamineSystem : ExamineSystemShared
+    public sealed class ExamineSystem : ExamineSystemShared
     {
         [Dependency] private readonly IUserInterfaceManager _userInterfaceManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;

Content.IntegrationTests/PoolManager.cs

@@ -14,6 +14,7 @@ using Content.IntegrationTests.Tests.Interaction.Click;
 using Content.IntegrationTests.Tests.Networking;
 using Content.Server.GameTicking;
 using Content.Shared.CCVar;
+using Microsoft.Diagnostics.Tracing.Parsers.Kernel;
 using NUnit.Framework;
 using Robust.Client;
 using Robust.Server;
@@ -561,6 +562,7 @@ we are just going to end this here to save a lot of time. This is the exception
         {
             var mapManager = IoCManager.Resolve<IMapManager>();
             mapData.MapId = mapManager.CreateMap();
+            mapData.MapUid = mapManager.GetMapEntityId(mapData.MapId);
             mapData.MapGrid = mapManager.CreateGrid(mapData.MapId);
             mapData.GridCoords = new EntityCoordinates(mapData.MapGrid.Owner, 0, 0);
             var tileDefinitionManager = IoCManager.Resolve<ITileDefinitionManager>();
@@ -790,6 +792,7 @@ public sealed class PoolSettings
 /// </summary>
 public sealed class TestMapData
 {
+    public EntityUid MapUid { get; set; }
     public MapId MapId { get; set; }
     public MapGridComponent MapGrid { get; set; }
     public EntityCoordinates GridCoords { get; set; }

Content.IntegrationTests/Tests/Construction/Interaction/ComputerContruction.cs

@@ -0,0 +1,99 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class ComputerConstruction : InteractionTest
+{
+    private const string Computer = "Computer";
+    private const string ComputerId = "ComputerId";
+    private const string ComputerFrame = "ComputerFrame";
+    private const string IdBoard = "IDComputerCircuitboard";
+
+    [Test]
+    public async Task ConstructComputer()
+    {
+        // Place ghost
+        await StartConstruction(Computer);
+
+        // Initial interaction (ghost turns into real entity)
+        await Interact(Steel, 5);
+        AssertPrototype(ComputerFrame);
+
+        // Perform construction steps
+        await Interact(
+            Wrench,
+            IdBoard,
+            Screw,
+            (Cable, 5),
+            (Glass, 2),
+            Screw);
+
+        // Construction finished, target entity was replaced with a new one:
+        AssertPrototype(ComputerId);
+    }
+
+    [Test]
+    public async Task DeconstructComputer()
+    {
+        // Spawn initial entity
+        await StartDeconstruction(ComputerId);
+
+        // Initial interaction turns id computer into generic computer
+        await Interact(Screw);
+        AssertPrototype(ComputerFrame);
+
+        // Perform deconstruction steps
+        await Interact(
+            Pry,
+            Cut,
+            Screw,
+            Pry,
+            Wrench,
+            Weld);
+
+        // construction finished, entity no longer exists.
+        AssertDeleted();
+
+        // Check expected entities were dropped.
+        await AssertEntityLookup(
+            IdBoard,
+            (Cable, 5),
+            (Steel, 5),
+            (Glass, 2));
+    }
+
+    [Test]
+    public async Task ChangeComputer()
+    {
+        // Spawn initial entity
+        await SpawnTarget(ComputerId);
+
+        // Initial interaction turns id computer into generic computer
+        await Interact(Screw);
+        AssertPrototype(ComputerFrame);
+
+        // Perform partial deconstruction steps
+        await Interact(
+            Pry,
+            Cut,
+            Screw,
+            Pry);
+
+        // Entity should still exist
+        AssertPrototype(ComputerFrame);
+
+        // Begin re-constructing with a new circuit board
+        await Interact(
+            "CargoRequestComputerCircuitboard",
+            Screw,
+            (Cable, 5),
+            (Glass, 2),
+            Screw);
+
+        // Construction finished, target entity was replaced with a new one:
+        AssertPrototype("ComputerCargoOrders");
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/CraftingTests.cs

@@ -0,0 +1,127 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.Containers;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class CraftingTests : InteractionTest
+{
+    public const string ShardGlass = "ShardGlass";
+    public const string Spear = "Spear";
+
+    /// <summary>
+    /// Craft a simple instant recipe
+    /// </summary>
+    [Test]
+    public async Task CraftRods()
+    {
+        await PlaceInHands(Steel);
+        await CraftItem(Rod);
+        await FindEntity((Rod, 2));
+    }
+
+    /// <summary>
+    /// Craft a simple recipe with a DoAfter
+    /// </summary>
+    [Test]
+    public async Task CraftGrenade()
+    {
+        await PlaceInHands(Steel, 5);
+        await CraftItem("ModularGrenadeRecipe");
+        await FindEntity("ModularGrenade");
+    }
+
+    /// <summary>
+    /// Craft a complex recipe (more than one ingredient).
+    /// </summary>
+    [Test]
+    public async Task CraftSpear()
+    {
+        // Spawn a full tack of rods in the user's hands.
+        await PlaceInHands(Rod, 10);
+        await SpawnEntity((Cable, 10), PlayerCoords);
+
+        // Attempt (and fail) to craft without glass.
+        await CraftItem(Spear, shouldSucceed: false);
+        await FindEntity(Spear, shouldSucceed: false);
+
+        // Spawn three shards of glass and finish crafting (only one is needed).
+        await SpawnTarget(ShardGlass);
+        await SpawnTarget(ShardGlass);
+        await SpawnTarget(ShardGlass);
+        await CraftItem(Spear);
+        await FindEntity(Spear);
+
+        // Player's hands should be full of the remaining rods, except those dropped during the failed crafting attempt.
+        // Spear and left over stacks should be on the floor.
+        await AssertEntityLookup((Rod, 2), (Cable, 8), (ShardGlass, 2), (Spear, 1));
+    }
+
+    // The following is wrapped in an if DEBUG. This is because of cursed state handling bugs. Tests don't (de)serialize
+    // net messages and just copy objects by reference. This means that the server will directly modify cached server
+    // states on the client's end. Crude fix at the moment is to used modified state handling while in debug mode
+    // Otherwise, this test cannot work.
+#if DEBUG
+    /// <summary>
+    /// Cancel crafting a complex recipe.
+    /// </summary>
+    [Test]
+    public async Task CancelCraft()
+    {
+        var rods = await SpawnEntity((Rod, 10), TargetCoords);
+        var wires = await SpawnEntity((Cable, 10), TargetCoords);
+        var shard = await SpawnEntity(ShardGlass, TargetCoords);
+
+        var rodStack = SEntMan.GetComponent<StackComponent>(rods);
+        var wireStack = SEntMan.GetComponent<StackComponent>(wires);
+
+        await RunTicks(5);
+        var sys = SEntMan.System<SharedContainerSystem>();
+        Assert.That(sys.IsEntityInContainer(rods), Is.False);
+        Assert.That(sys.IsEntityInContainer(wires), Is.False);
+        Assert.That(sys.IsEntityInContainer(shard), Is.False);
+
+        await Server.WaitPost(() => SConstruction.TryStartItemConstruction(Spear, Player));
+        await RunTicks(1);
+
+        // DoAfter is in progress. Entity not spawned, stacks have been split and someingredients are in a container.
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+        Assert.That(sys.IsEntityInContainer(shard), Is.True);
+        Assert.That(sys.IsEntityInContainer(rods), Is.False);
+        Assert.That(sys.IsEntityInContainer(wires), Is.False);
+        Assert.That(rodStack.Count, Is.EqualTo(8));
+        Assert.That(wireStack.Count, Is.EqualTo(8));
+        await FindEntity(Spear, shouldSucceed: false);
+
+        // Cancel the DoAfter. Should drop ingredients to the floor.
+        await CancelDoAfters();
+        Assert.That(sys.IsEntityInContainer(rods), Is.False);
+        Assert.That(sys.IsEntityInContainer(wires), Is.False);
+        Assert.That(sys.IsEntityInContainer(shard), Is.False);
+        await FindEntity(Spear, shouldSucceed: false);
+        await AssertEntityLookup((Rod, 10), (Cable, 10), (ShardGlass, 1));
+
+        // Re-attempt the do-after
+        await Server.WaitPost(() => SConstruction.TryStartItemConstruction(Spear, Player));
+        await RunTicks(1);
+
+        // DoAfter is in progress. Entity not spawned, ingredients are in a container.
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+        Assert.That(sys.IsEntityInContainer(shard), Is.True);
+        await FindEntity(Spear, shouldSucceed: false);
+
+        // Finish the DoAfter
+        await AwaitDoAfters();
+
+        // Spear has been crafted. Rods and wires are no longer contained. Glass has been consumed.
+        await FindEntity(Spear);
+        Assert.That(sys.IsEntityInContainer(rods), Is.False);
+        Assert.That(sys.IsEntityInContainer(wires), Is.False);
+        Assert.That(SEntMan.Deleted(shard));
+    }
+#endif
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/GrilleWindowConstruction.cs

@@ -0,0 +1,59 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Construction.Prototypes;
+using NUnit.Framework;
+using Robust.Shared.Maths;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+/// <summary>
+///     Check that we can build grilles on top of windows, but not the other way around.
+/// </summary>
+public sealed class GrilleWindowConstruction : InteractionTest
+{
+    private const string Grille = "Grille";
+    private const string Window = "Window";
+
+    [Test]
+    public async Task WindowOnGrille()
+    {
+        // Construct Grille
+        await StartConstruction(Grille);
+        await Interact(Rod, 10);
+        AssertPrototype(Grille);
+
+        var grille = Target;
+
+        // Construct Window
+        await StartConstruction(Window);
+        await Interact(Glass, 10);
+        AssertPrototype(Window);
+
+        // Deconstruct Window
+        await Interact(Screw, Wrench);
+        AssertDeleted();
+
+        // Deconstruct Grille
+        Target = grille;
+        await Interact(Cut);
+        AssertDeleted();
+    }
+
+    [Test]
+    [TestCase(Grille, Grille)]
+    [TestCase(Window, Grille)]
+    [TestCase(Window, Window)]
+    public async Task ConstructionBlocker(string first, string second)
+    {
+        // Spawn blocking entity
+        await SpawnTarget(first);
+
+        // Further construction attempts fail - blocked by first entity interaction.
+        await Client.WaitPost(() =>
+        {
+            var proto = ProtoMan.Index<ConstructionPrototype>(second);
+            Assert.That(CConSys.TrySpawnGhost(proto, TargetCoords, Direction.South, out _), Is.False);
+        });
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/MachineConstruction.cs

@@ -0,0 +1,89 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class MachineConstruction : InteractionTest
+{
+    private const string MachineFrame = "MachineFrame";
+    private const string Unfinished = "UnfinishedMachineFrame";
+    private const string ProtolatheBoard = "ProtolatheMachineCircuitboard";
+    private const string Protolathe = "Protolathe";
+    private const string Beaker = "Beaker";
+
+    [Test]
+    public async Task ConstructProtolathe()
+    {
+        await StartConstruction(MachineFrame);
+        await Interact(Steel, 5);
+        AssertPrototype(Unfinished);
+        await Interact(Wrench, Cable);
+        AssertPrototype(MachineFrame);
+        await Interact(ProtolatheBoard, Bin1, Bin1, Manipulator1, Manipulator1, Beaker, Beaker, Screw);
+        AssertPrototype(Protolathe);
+    }
+
+    [Test]
+    public async Task DeconstructProtolathe()
+    {
+        await StartDeconstruction(Protolathe);
+        await Interact(Screw, Pry);
+        AssertPrototype(MachineFrame);
+        await Interact(Pry, Cut);
+        AssertPrototype(Unfinished);
+        await Interact(Wrench, Screw);
+        AssertDeleted();
+        await AssertEntityLookup(
+            (Steel, 5),
+            (Cable, 1),
+            (Beaker, 2),
+            (Manipulator1, 2),
+            (Bin1, 2),
+            (ProtolatheBoard, 1));
+    }
+
+    [Test]
+    public async Task ChangeMachine()
+    {
+        // Partially deconstruct a protolathe.
+        await SpawnTarget(Protolathe);
+        await Interact(Screw, Pry, Pry);
+        AssertPrototype(MachineFrame);
+
+        // Change it into an autolathe
+        await Interact("AutolatheMachineCircuitboard");
+        AssertPrototype(MachineFrame);
+        await Interact(Bin1, Bin1, Bin1, Manipulator1, Glass, Screw);
+        AssertPrototype("Autolathe");
+    }
+
+    [Test]
+    public async Task UpgradeLathe()
+    {
+        // Partially deconstruct a protolathe.
+        await SpawnTarget(Protolathe);
+
+        // Initially has all quality-1 parts.
+        foreach (var part in SConstruction.GetAllParts(Target!.Value))
+        {
+            Assert.That(part.Rating, Is.EqualTo(1));
+        }
+
+        // Partially deconstruct lathe
+        await Interact(Screw, Pry, Pry);
+        AssertPrototype(MachineFrame);
+
+        // Reconstruct with better parts.
+        await Interact(ProtolatheBoard, Bin4, Bin4, Manipulator4, Manipulator4, Beaker, Beaker);
+        await Interact(Screw);
+        AssertPrototype(Protolathe);
+
+        // Query now returns higher quality parts.
+        foreach (var part in SConstruction.GetAllParts(Target!.Value))
+        {
+            Assert.That(part.Rating, Is.EqualTo(4));
+        }
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/PanelScrewing.cs

@@ -0,0 +1,69 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Power.Components;
+using Content.Shared.Wires;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class PanelScrewing : InteractionTest
+{
+    [Test]
+    public async Task ApcPanel()
+    {
+        await SpawnTarget("APCBasic");
+        var comp = Comp<ApcComponent>();
+
+        // Open & close panel
+        Assert.That(comp.IsApcOpen, Is.False);
+
+        await Interact(Screw);
+        Assert.That(comp.IsApcOpen, Is.True);
+        await Interact(Screw);
+        Assert.That(comp.IsApcOpen, Is.False);
+
+        // Interrupted DoAfters
+        await Interact(Screw, awaitDoAfters: false);
+        await CancelDoAfters();
+        Assert.That(comp.IsApcOpen, Is.False);
+        await Interact(Screw);
+        Assert.That(comp.IsApcOpen, Is.True);
+        await Interact(Screw, awaitDoAfters: false);
+        await CancelDoAfters();
+        Assert.That(comp.IsApcOpen, Is.True);
+        await Interact(Screw);
+        Assert.That(comp.IsApcOpen, Is.False);
+    }
+
+    // Test wires panel on both airlocks & tcomms servers. These both use the same component, but comms may have
+    // conflicting interactions due to encryption key removal interactions.
+    [Test]
+    [TestCase("Airlock")]
+    [TestCase("TelecomServerFilled")]
+    public async Task WiresPanelScrewing(string prototype)
+    {
+        await SpawnTarget(prototype);
+        var comp = Comp<WiresPanelComponent>();
+
+        // Open & close panel
+        Assert.That(comp.Open, Is.False);
+        await Interact(Screw);
+        Assert.That(comp.Open, Is.True);
+        await Interact(Screw);
+        Assert.That(comp.Open, Is.False);
+
+        // Interrupted DoAfters
+        await Interact(Screw, awaitDoAfters: false);
+        await CancelDoAfters();
+        Assert.That(comp.Open, Is.False);
+        await Interact(Screw);
+        Assert.That(comp.Open, Is.True);
+        await Interact(Screw, awaitDoAfters: false);
+        await CancelDoAfters();
+        Assert.That(comp.Open, Is.True);
+        await Interact(Screw);
+        Assert.That(comp.Open, Is.False);
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/PlaceableDeconstruction.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Placeable;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class PlaceableDeconstruction : InteractionTest
+{
+    /// <summary>
+    /// Checks that you can deconstruct placeable surfaces (i.e., placing a wrench on a table does not take priority).
+    /// </summary>
+    [Test]
+    public async Task DeconstructTable()
+    {
+        await StartDeconstruction("Table");
+        Assert.That(Comp<PlaceableSurfaceComponent>().IsPlaceable);
+        await Interact(Wrench);
+        AssertPrototype("TableFrame");
+        await Interact(Wrench);
+        AssertDeleted();
+        await AssertEntityLookup((Steel, 1), (Rod, 2));
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/WallConstruction.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WallConstruction : InteractionTest
+{
+    public const string Girder = "Girder";
+    public const string WallSolid = "WallSolid";
+    public const string Wall = "Wall";
+
+    [Test]
+    public async Task ConstructWall()
+    {
+        await StartConstruction(Wall);
+        await Interact(Steel, 2);
+        Assert.IsNull(Hands.ActiveHandEntity);
+        AssertPrototype(Girder);
+        await Interact(Steel, 2);
+        Assert.IsNull(Hands.ActiveHandEntity);
+        AssertPrototype(WallSolid);
+    }
+
+    [Test]
+    public async Task DeconstructWall()
+    {
+        await StartDeconstruction(WallSolid);
+        await Interact(Weld);
+        AssertPrototype(Girder);
+        await Interact(Wrench, Screw);
+        AssertDeleted();
+        await AssertEntityLookup((Steel, 4));
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/WindowConstruction.cs

@@ -0,0 +1,52 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WindowConstruction : InteractionTest
+{
+    private const string Window = "Window";
+    private const string RWindow = "ReinforcedWindow";
+
+    [Test]
+    public async Task ConstructWindow()
+    {
+        await StartConstruction(Window);
+        await Interact(Glass, 5);
+        AssertPrototype(Window);
+    }
+
+    [Test]
+    public async Task DeconstructWindow()
+    {
+        await StartDeconstruction(Window);
+        await Interact(Screw, Wrench);
+        AssertDeleted();
+        await AssertEntityLookup((Glass, 2));
+    }
+
+    [Test]
+    public async Task ConstructReinforcedWindow()
+    {
+        await StartConstruction(RWindow);
+        await Interact(RGlass, 5);
+        AssertPrototype(RWindow);
+    }
+
+    [Test]
+    public async Task DeonstructReinforcedWindow()
+    {
+        await StartDeconstruction(RWindow);
+        await Interact(
+            Weld,
+            Screw,
+            Pry,
+            Weld,
+            Screw,
+            Wrench);
+        AssertDeleted();
+        await AssertEntityLookup((RGlass, 2));
+    }
+}
+

Content.IntegrationTests/Tests/Construction/Interaction/WindowRepair.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Content.Shared.FixedPoint;
+using NUnit.Framework;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Construction.Interaction;
+
+public sealed class WindowRepair : InteractionTest
+{
+    [Test]
+    public async Task RepairReinforcedWindow()
+    {
+        await SpawnTarget("ReinforcedWindow");
+
+        // Damage the entity.
+        var sys = SEntMan.System<DamageableSystem>();
+        var comp = Comp<DamageableComponent>();
+        var damageType = Server.ResolveDependency<IPrototypeManager>().Index<DamageTypePrototype>("Blunt");
+        var damage = new DamageSpecifier(damageType, FixedPoint2.New(10));
+        Assert.That(comp.Damage.Total, Is.EqualTo(FixedPoint2.Zero));
+        await Server.WaitPost(() => sys.TryChangeDamage(Target, damage, ignoreResistances: true));
+        await RunTicks(5);
+        Assert.That(comp.Damage.Total, Is.GreaterThan(FixedPoint2.Zero));
+
+        // Repair the entity
+        await Interact(Weld);
+        Assert.That(comp.Damage.Total, Is.EqualTo(FixedPoint2.Zero));
+
+        // Validate that we can still deconstruct the entity (i.e., that welding deconstruction is not blocked).
+        await Interact(
+            Weld,
+            Screw,
+            Pry,
+            Weld,
+            Screw,
+            Wrench);
+        AssertDeleted();
+        await AssertEntityLookup((RGlass, 2));
+    }
+}
+

Content.IntegrationTests/Tests/DoAfter/DoAfterCancellationTests.cs

@@ -0,0 +1,136 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Construction.Interaction;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.IntegrationTests.Tests.Weldable;
+using Content.Server.Tools.Components;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.DoAfter;
+
+/// <summary>
+/// This class has various tests that verify that cancelled DoAfters do not complete construction or other interactions.
+/// It also checks that cancellation of a DoAfter does not block future DoAfters.
+/// </summary>
+public sealed class DoAfterCancellationTests : InteractionTest
+{
+    [Test]
+    public async Task CancelWallDeconstruct()
+    {
+        await StartDeconstruction(WallConstruction.WallSolid);
+        await Interact(Weld, awaitDoAfters:false);
+
+        // Failed do-after has no effect
+        await CancelDoAfters();
+        AssertPrototype(WallConstruction.WallSolid);
+
+        // Second attempt works fine
+        await Interact(Weld);
+        AssertPrototype(WallConstruction.Girder);
+
+        // Repeat for wrenching interaction
+        AssertAnchored();
+        await Interact(Wrench, awaitDoAfters:false);
+        await CancelDoAfters();
+        AssertAnchored();
+        AssertPrototype(WallConstruction.Girder);
+        await Interact(Wrench);
+        AssertAnchored(false);
+
+        // Repeat for screwdriver interaction.
+        AssertDeleted(false);
+        await Interact(Screw, awaitDoAfters:false);
+        await CancelDoAfters();
+        AssertDeleted(false);
+        await Interact(Screw);
+        AssertDeleted();
+    }
+
+    [Test]
+    public async Task CancelWallConstruct()
+    {
+        await StartConstruction(WallConstruction.Wall);
+        await Interact(Steel, 5, awaitDoAfters:false);
+        await CancelDoAfters();
+        Assert.That(Target.HasValue && Target.Value.IsClientSide());
+
+        await Interact(Steel, 5);
+        AssertPrototype(WallConstruction.Girder);
+        await Interact(Steel, 5, awaitDoAfters:false);
+        await CancelDoAfters();
+        AssertPrototype(WallConstruction.Girder);
+
+        await Interact(Steel, 5);
+        AssertPrototype(WallConstruction.WallSolid);
+    }
+
+    [Test]
+    public async Task CancelTilePry()
+    {
+        await SetTile(Floor);
+        await Interact(Pry, awaitDoAfters:false);
+        await CancelDoAfters();
+        await AssertTile(Floor);
+
+        await Interact(Pry);
+        await AssertTile(Plating);
+    }
+
+    [Test]
+    public async Task CancelRepeatedTilePry()
+    {
+        await SetTile(Floor);
+        await Interact(Pry, awaitDoAfters:false);
+        await RunTicks(1);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+        await AssertTile(Floor);
+
+        // Second DoAfter cancels the first.
+        await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        await AssertTile(Floor);
+
+        // Third do after will work fine
+        await Interact(Pry);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        await AssertTile(Plating);
+    }
+
+    [Test]
+    public async Task CancelRepeatedWeld()
+    {
+        await SpawnTarget(WeldableTests.Locker);
+        var comp = Comp<WeldableComponent>();
+
+        Assert.That(comp.Weldable, Is.True);
+        Assert.That(comp.IsWelded, Is.False);
+
+        await Interact(Weld, awaitDoAfters:false);
+        await RunTicks(1);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+        Assert.That(comp.IsWelded, Is.False);
+
+        // Second DoAfter cancels the first.
+        // Not using helper, because it runs too many ticks & causes the do-after to finish.
+        await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        Assert.That(comp.IsWelded, Is.False);
+
+        // Third do after will work fine
+        await Interact(Weld);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        Assert.That(comp.IsWelded, Is.True);
+
+        // Repeat test for un-welding
+        await Interact(Weld, awaitDoAfters:false);
+        await RunTicks(1);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(1));
+        Assert.That(comp.IsWelded, Is.True);
+        await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        Assert.That(comp.IsWelded, Is.True);
+        await Interact(Weld);
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+        Assert.That(comp.IsWelded, Is.False);
+    }
+}

Content.IntegrationTests/Tests/EncryptionKeys/RemoveEncryptionKeys.cs

@@ -0,0 +1,88 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Shared.Radio.Components;
+using Content.Shared.Wires;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.EncryptionKeys;
+
+public sealed class RemoveEncryptionKeys : InteractionTest
+{
+    [Test]
+    public async Task HeadsetKeys()
+    {
+        await SpawnTarget("ClothingHeadsetGrey");
+        var comp = Comp<EncryptionKeyHolderComponent>();
+
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+        Assert.That(comp.DefaultChannel, Is.EqualTo("Common"));
+        Assert.That(comp.Channels.Count, Is.EqualTo(1));
+        Assert.That(comp.Channels.First(), Is.EqualTo("Common"));
+
+        // Remove the key
+        await Interact(Screw);
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+        Assert.IsNull(comp.DefaultChannel);
+        Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+        // Checkl that the key was ejected and not just deleted or something.
+        await AssertEntityLookup(("EncryptionKeyCommon", 1));
+
+        // Re-insert a key.
+        await Interact("EncryptionKeyCentCom");
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+        Assert.That(comp.DefaultChannel, Is.EqualTo("CentCom"));
+        Assert.That(comp.Channels.Count, Is.EqualTo(1));
+        Assert.That(comp.Channels.First(), Is.EqualTo("CentCom"));
+    }
+
+    [Test]
+    public async Task CommsServerKeys()
+    {
+        await SpawnTarget("TelecomServerFilled");
+        var comp = Comp<EncryptionKeyHolderComponent>();
+        var panel = Comp<WiresPanelComponent>();
+
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+        Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+        Assert.That(panel.Open, Is.False);
+
+        // cannot remove keys without opening panel
+        await Interact(Pry);
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+        Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+        Assert.That(panel.Open, Is.False);
+
+        // Open panel
+        await Interact(Screw);
+        Assert.That(panel.Open, Is.True);
+
+        // Keys are still here
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.GreaterThan(0));
+        Assert.That(comp.Channels.Count, Is.GreaterThan(0));
+
+        // Now remove the keys
+        await Interact(Pry);
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+        Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+        // Reinsert a key
+        await Interact("EncryptionKeyCentCom");
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(1));
+        Assert.That(comp.DefaultChannel, Is.EqualTo("CentCom"));
+        Assert.That(comp.Channels.Count, Is.EqualTo(1));
+        Assert.That(comp.Channels.First(), Is.EqualTo("CentCom"));
+
+        // Remove it again
+        await Interact(Pry);
+        Assert.That(comp.KeyContainer.ContainedEntities.Count, Is.EqualTo(0));
+        Assert.That(comp.Channels.Count, Is.EqualTo(0));
+
+        // Prying again will start deconstructing the machine.
+        AssertPrototype("TelecomServerFilled");
+        await Interact(Pry);
+        AssertPrototype("MachineFrame");
+    }
+}
+

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

@@ -92,6 +92,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 Assert.That(interactUsing);
             });
 
+            testInteractionSystem.ClearHandlers();
             await pairTracker.CleanReturnAsync();
         }
 
@@ -154,6 +155,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 Assert.That(interactUsing, Is.False);
             });
 
+            testInteractionSystem.ClearHandlers();
             await pairTracker.CleanReturnAsync();
         }
 
@@ -214,6 +216,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 Assert.That(interactUsing);
             });
 
+            testInteractionSystem.ClearHandlers();
             await pairTracker.CleanReturnAsync();
         }
 
@@ -275,6 +278,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 Assert.That(interactUsing, Is.False);
             });
 
+            testInteractionSystem.ClearHandlers();
             await pairTracker.CleanReturnAsync();
         }
 
@@ -352,6 +356,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 Assert.That(interactUsing, Is.True);
             });
 
+            testInteractionSystem.ClearHandlers();
             await pairTracker.CleanReturnAsync();
         }
 
@@ -367,6 +372,12 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
                 SubscribeLocalEvent<InteractUsingEvent>((e) => InteractUsingEvent?.Invoke(e));
                 SubscribeLocalEvent<InteractHandEvent>((e) => InteractHandEvent?.Invoke(e));
             }
+
+            public void ClearHandlers()
+            {
+                InteractUsingEvent = null;
+                InteractHandEvent = null;
+            }
         }
 
     }

Content.IntegrationTests/Tests/Interaction/InteractionTest.Constants.cs

@@ -0,0 +1,43 @@
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+// This partial class contains various constant prototype IDs common to interaction tests.
+// Should make it easier to mass-change hard coded strings if prototypes get renamed.
+public abstract partial class InteractionTest
+{
+    protected const string PlayerEntity = "AdminObserver";
+
+    // Tiles
+    protected const string Floor = "FloorSteel";
+    protected const string FloorItem = "FloorTileItemSteel";
+    protected const string Plating = "Plating";
+    protected const string Lattice = "Lattice";
+
+    // Tools/steps
+    protected const string Wrench = "Wrench";
+    protected const string Screw = "Screwdriver";
+    protected const string Weld = "WelderExperimental";
+    protected const string Pry = "Crowbar";
+    protected const string Cut = "Wirecutter";
+
+    // Materials/stacks
+    protected const string Steel = "Steel";
+    protected const string Glass = "Glass";
+    protected const string RGlass = "ReinforcedGlass";
+    protected const string Plastic = "Plastic";
+    protected const string Cable = "Cable";
+    protected const string Rod = "MetalRod";
+
+    // Parts
+    protected const string Bin1 = "MatterBinStockPart";
+    protected const string Bin4 = "BluespaceMatterBinStockPart";
+    protected const string Cap1 = "CapacitorStockPart";
+    protected const string Cap4 = "QuadraticCapacitorStockPart";
+    protected const string Manipulator1 = "MicroManipulatorStockPart";
+    protected const string Manipulator4 = "FemtoManipulatorStockPart";
+    protected const string Laser1 = "MicroLaserStockPart";
+    protected const string Laser2 = "QuadUltraMicroLaserStockPart";
+    protected const string Battery1 = "PowerCellSmall";
+    protected const string Battery4 = "PowerCellHyper";
+}
+

Content.IntegrationTests/Tests/Interaction/InteractionTest.EntitySpecifier.cs

@@ -0,0 +1,126 @@
+#nullable enable
+using System.Threading.Tasks;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+public abstract partial class InteractionTest
+{
+    /// <summary>
+    /// Utility class for working with prototypes ids that may refer to stacks or entities.
+    /// </summary>
+    /// <remarks>
+    /// Intended to make tests easier by removing ambiguity around "SheetSteel1", "SheetSteel", and "Steel". All three
+    /// should be treated identically by interaction tests.
+    /// </remarks>
+    protected sealed class EntitySpecifier
+    {
+        /// <summary>
+        /// Either the stack or entity prototype for this entity. Stack prototypes take priority.
+        /// </summary>
+        public string Prototype;
+
+        /// <summary>
+        /// The quantity. If the entity has a stack component, this is the total stack quantity.
+        /// Otherwise this is the number of entities.
+        /// </summary>
+        /// <remarks>
+        /// If used for spawning and this number is larger than the max stack size, only a single stack will be spawned.
+        /// </remarks>
+        public int Quantity;
+
+        /// <summary>
+        /// If true, a check has been performed to see if the prototype ia an entity prototype with a stack component,
+        /// in which case the specifier was converted into a stack-specifier
+        /// </summary>
+        public bool Converted;
+
+        public EntitySpecifier(string prototype, int quantity, bool converted = false)
+        {
+            Assert.That(quantity > 0);
+            Prototype = prototype;
+            Quantity = quantity;
+            Converted = converted;
+        }
+
+        public static implicit operator EntitySpecifier(string prototype)
+            => new(prototype, 1);
+
+        public static implicit operator EntitySpecifier((string, int) tuple)
+            => new(tuple.Item1, tuple.Item2);
+
+        /// <summary>
+        /// Convert applicable entity prototypes into stack prototypes.
+        /// </summary>
+        public void ConvertToStack(IPrototypeManager protoMan, IComponentFactory factory)
+        {
+            if (Converted)
+                return;
+
+            Converted = true;
+            if (protoMan.HasIndex<StackPrototype>(Prototype))
+                return;
+
+            if (!protoMan.TryIndex<EntityPrototype>(Prototype, out var entProto))
+            {
+                Assert.Fail($"Unknown prototype: {Prototype}");
+                return;
+            }
+
+            if (entProto.TryGetComponent<StackComponent>(factory.GetComponentName(typeof(StackComponent)),
+                    out var stackComp))
+            {
+                Prototype = stackComp.StackTypeId;
+            }
+        }
+    }
+
+    protected async Task<EntityUid> SpawnEntity(EntitySpecifier spec, EntityCoordinates coords)
+    {
+        EntityUid uid = default!;
+        if (ProtoMan.TryIndex<StackPrototype>(spec.Prototype, out var stackProto))
+        {
+            await Server.WaitPost(() =>
+            {
+                uid = SEntMan.SpawnEntity(stackProto.Spawn, coords);
+                Stack.SetCount(uid, spec.Quantity);
+            });
+            return uid;
+        }
+
+        if (!ProtoMan.TryIndex<EntityPrototype>(spec.Prototype, out var entProto))
+        {
+            Assert.Fail($"Unkown prototype: {spec.Prototype}");
+            return default;
+        }
+
+        if (entProto.TryGetComponent<StackComponent>(Factory.GetComponentName(typeof(StackComponent)),
+                out var stackComp))
+        {
+            return await SpawnEntity((stackComp.StackTypeId, spec.Quantity), coords);
+        }
+
+        Assert.That(spec.Quantity, Is.EqualTo(1), "SpawnEntity only supports returning a singular entity");
+        await Server.WaitPost(() => uid = SEntMan.SpawnEntity(spec.Prototype, coords));;
+        return uid;
+    }
+
+    /// <summary>
+    /// Convert an entity-uid to a matching entity specifier. Usefull when doing entity lookups & checking that the
+    /// right quantity of entities/materials werre produced.
+    /// </summary>
+    protected EntitySpecifier ToEntitySpecifier(EntityUid uid)
+    {
+        if (SEntMan.TryGetComponent(uid, out StackComponent? stack))
+            return new EntitySpecifier(stack.StackTypeId, stack.Count) {Converted = true};
+
+        var meta = SEntMan.GetComponent<MetaDataComponent>(uid);
+        Assert.NotNull(meta.EntityPrototype);
+
+        return new (meta.EntityPrototype.ID, 1) { Converted = true };
+    }
+}

Content.IntegrationTests/Tests/Interaction/InteractionTest.EntitySpecifierCollection.cs

@@ -0,0 +1,160 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Content.Shared.Stacks;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+public abstract partial class InteractionTest
+{
+    /// <summary>
+    /// Data structure for representing a collection of <see cref="EntitySpecifier"/>s.
+    /// </summary>
+    protected sealed class EntitySpecifierCollection
+    {
+        public Dictionary<string, int> Entities = new();
+
+        /// <summary>
+        /// If true, a check has been performed to see if the prototypes correspond to entity prototypes with a stack
+        /// component, in which case the specifier was converted into a stack-specifier
+        /// </summary>
+        public bool Converted;
+
+        public EntitySpecifierCollection()
+        {
+            Converted = true;
+        }
+
+        public EntitySpecifierCollection(IEnumerable<EntitySpecifier> ents)
+        {
+            Converted = true;
+            foreach (var ent in ents)
+            {
+                Add(ent);
+            }
+        }
+
+        public static implicit operator EntitySpecifierCollection(string prototype)
+        {
+            var result = new EntitySpecifierCollection();
+            result.Add(prototype, 1);
+            return result;
+        }
+
+        public static implicit operator EntitySpecifierCollection((string, int) tuple)
+        {
+            var result = new EntitySpecifierCollection();
+            result.Add(tuple.Item1, tuple.Item2);
+            return result;
+        }
+
+        public void Remove(EntitySpecifier spec)
+            => Add(new EntitySpecifier(spec.Prototype, -spec.Quantity, spec.Converted));
+
+        public void Add(EntitySpecifier spec)
+            => Add(spec.Prototype, spec.Quantity, spec.Converted);
+
+        public void Add(string id, int quantity, bool converted = false)
+        {
+            Converted &= converted;
+
+            if (!Entities.TryGetValue(id, out var existing))
+            {
+                if (quantity != 0)
+                    Entities.Add(id, quantity);
+                return;
+            }
+
+            var newQuantity = quantity + existing;
+            if (newQuantity == 0)
+                Entities.Remove(id);
+            else
+                Entities[id] = newQuantity;
+        }
+
+        public void Add(EntitySpecifierCollection collection)
+        {
+            var converted = Converted && collection.Converted;
+            foreach (var (id, quantity) in collection.Entities)
+            {
+                Add(id, quantity);
+            }
+            Converted = converted;
+        }
+
+        public void Remove(EntitySpecifierCollection collection)
+        {
+            var converted = Converted && collection.Converted;
+            foreach (var (id, quantity) in collection.Entities)
+            {
+                Add(id, -quantity);
+            }
+            Converted = converted;
+        }
+
+        public EntitySpecifierCollection Clone()
+        {
+            return new EntitySpecifierCollection()
+            {
+                Entities = Entities.ShallowClone(),
+                Converted = Converted
+            };
+        }
+
+        /// <summary>
+        /// Convert applicable entity prototypes into stack prototypes.
+        /// </summary>
+        public void ConvertToStacks(IPrototypeManager protoMan, IComponentFactory factory)
+        {
+            if (Converted)
+                return;
+
+            HashSet<string> toRemove = new();
+            List<(string, int)> toAdd = new();
+            foreach (var (id, quantity) in Entities)
+            {
+
+                if (protoMan.HasIndex<StackPrototype>(id))
+                    continue;
+
+                if (!protoMan.TryIndex<EntityPrototype>(id, out var entProto))
+                {
+                    Assert.Fail($"Unknown prototype: {id}");
+                    continue;
+                }
+
+                if (!entProto.TryGetComponent<StackComponent>(factory.GetComponentName(typeof(StackComponent)),
+                        out var stackComp))
+                {
+                    continue;
+                }
+
+                toRemove.Add(id);
+                toAdd.Add((stackComp.StackTypeId, quantity));
+            }
+
+            foreach (var id in toRemove)
+            {
+                Entities.Remove(id);
+            }
+
+            foreach (var (id, quantity) in toAdd)
+            {
+                Add(id, quantity);
+            }
+
+            Converted = true;
+        }
+    }
+
+    protected EntitySpecifierCollection ToEntityCollection(IEnumerable<EntityUid> entities)
+    {
+        var collection = new EntitySpecifierCollection(entities.Select(uid => ToEntitySpecifier(uid)));
+        Assert.That(collection.Converted);
+        return collection;
+    }
+}

Content.IntegrationTests/Tests/Interaction/InteractionTest.Helpers.cs

@@ -0,0 +1,614 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Client.Construction;
+using Content.Server.Construction.Components;
+using Content.Server.Tools.Components;
+using Content.Shared.Construction.Prototypes;
+using Content.Shared.Item;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Maths;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+// This partial class defines various methods that are useful for performing & validating interactions
+public abstract partial class InteractionTest
+{
+    /// <summary>
+    /// Begin constructing an entity.
+    /// </summary>
+    protected async Task StartConstruction(string prototype, bool shouldSucceed = true)
+    {
+        var proto = ProtoMan.Index<ConstructionPrototype>(prototype);
+        Assert.That(proto.Type, Is.EqualTo(ConstructionType.Structure));
+
+        await Client.WaitPost(() =>
+        {
+            Assert.That(CConSys.TrySpawnGhost(proto, TargetCoords, Direction.South, out Target),
+                Is.EqualTo(shouldSucceed));
+
+            if (!shouldSucceed)
+                return;
+            var comp = CEntMan.GetComponent<ConstructionGhostComponent>(Target!.Value);
+            ConstructionGhostId = comp.GhostId;
+        });
+
+        await RunTicks(1);
+    }
+
+    /// <summary>
+    /// Craft an item.
+    /// </summary>
+    protected async Task CraftItem(string prototype, bool shouldSucceed = true)
+    {
+        Assert.That(ProtoMan.Index<ConstructionPrototype>(prototype).Type, Is.EqualTo(ConstructionType.Item));
+
+        // Please someone purge async construction code
+        Task<bool> task =default!;
+        await Server.WaitPost(() => task = SConstruction.TryStartItemConstruction(prototype, Player));
+
+        Task? tickTask = null;
+        while (!task.IsCompleted)
+        {
+            tickTask = PoolManager.RunTicksSync(PairTracker.Pair, 1);
+            await Task.WhenAny(task, tickTask);
+        }
+
+        if (tickTask != null)
+            await tickTask;
+
+#pragma warning disable RA0004
+        Assert.That(task.Result, Is.EqualTo(shouldSucceed));
+#pragma warning restore RA0004
+
+        await RunTicks(5);
+    }
+
+    /// <summary>
+    /// Spawn an entity entity and set it as the target.
+    /// </summary>
+    protected async Task SpawnTarget(string prototype)
+    {
+        await Server.WaitPost(() =>
+        {
+            Target = SEntMan.SpawnEntity(prototype, TargetCoords);
+        });
+
+        await RunTicks(5);
+        AssertPrototype(prototype);
+    }
+
+    /// <summary>
+    /// Spawn an entity in preparation for deconstruction
+    /// </summary>
+    protected async Task StartDeconstruction(string prototype)
+    {
+        await SpawnTarget(prototype);
+        Assert.That(SEntMan.TryGetComponent(Target, out ConstructionComponent? comp));
+        await Server.WaitPost(() => SConstruction.SetPathfindingTarget(Target!.Value, comp!.DeconstructionNode, comp));
+        await RunTicks(5);
+    }
+
+    /// <summary>
+    /// Drops and deletes the currently held entity.
+    /// </summary>
+    protected async Task DeleteHeldEntity()
+    {
+        if (Hands.ActiveHandEntity is {} held)
+        {
+            await Server.WaitPost(() =>
+            {
+                Assert.That(HandSys.TryDrop(Player, null, false, true, Hands));
+                SEntMan.DeleteEntity(held);
+                Logger.Debug($"Deleting held entity");
+            });
+        }
+
+        await RunTicks(1);
+        Assert.That(Hands.ActiveHandEntity == null);
+    }
+
+    /// <summary>
+    /// Place an entity prototype into the players hand. Deletes any currently held entity.
+    /// </summary>
+    /// <remarks>
+    /// Automatically enables welders.
+    /// </remarks>
+    protected async Task<EntityUid?> PlaceInHands(string? id, int quantity = 1, bool enableWelder = true)
+        => await PlaceInHands(id == null ? null : (id, quantity), enableWelder);
+
+    /// <summary>
+    /// Place an entity prototype into the players hand. Deletes any currently held entity.
+    /// </summary>
+    /// <remarks>
+    /// Automatically enables welders.
+    /// </remarks>
+    protected async Task<EntityUid?> PlaceInHands(EntitySpecifier? entity, bool enableWelder = true)
+    {
+        if (Hands.ActiveHand == null)
+        {
+            Assert.Fail("No active hand");
+            return default;
+        }
+
+        await DeleteHeldEntity();
+
+        if (entity == null)
+        {
+            await RunTicks(1);
+            Assert.That(Hands.ActiveHandEntity == null);
+            return null;
+        }
+
+        // spawn and pick up the new item
+        EntityUid item = await SpawnEntity(entity, PlayerCoords);
+        WelderComponent? welder = null;
+
+        await Server.WaitPost(() =>
+        {
+            Assert.That(HandSys.TryPickup(Player, item, Hands.ActiveHand, false, false, false, Hands));
+
+            // turn on welders
+            if (enableWelder && SEntMan.TryGetComponent(item, out welder) && !welder.Lit)
+                Assert.That(ToolSys.TryTurnWelderOn(item, Player, welder));
+        });
+
+        await RunTicks(1);
+        Assert.That(Hands.ActiveHandEntity, Is.EqualTo(item));
+        if (enableWelder && welder != null)
+            Assert.That(welder.Lit);
+
+        return item;
+    }
+
+    /// <summary>
+    /// Pick up an entity. Defaults to just deleting the previously held entity.
+    /// </summary>
+    protected async Task Pickup(EntityUid? uid = null, bool deleteHeld = true)
+    {
+        uid ??= Target;
+
+        if (Hands.ActiveHand == null)
+        {
+            Assert.Fail("No active hand");
+            return;
+        }
+
+        if (deleteHeld)
+            await DeleteHeldEntity();
+
+        if (!SEntMan.TryGetComponent(uid, out ItemComponent? item))
+        {
+            Assert.Fail($"Entity {uid} is not an item");
+            return;
+        }
+
+        await Server.WaitPost(() =>
+        {
+            Assert.That(HandSys.TryPickup(Player, uid!.Value, Hands.ActiveHand, false, false, false, Hands, item));
+        });
+
+        await RunTicks(1);
+        Assert.That(Hands.ActiveHandEntity, Is.EqualTo(uid));
+    }
+
+    /// <summary>
+    /// Drops the currently held entity.
+    /// </summary>
+    protected async Task Drop()
+    {
+        if (Hands.ActiveHandEntity == null)
+        {
+            Assert.Fail("Not holding any entity to drop");
+            return;
+        }
+
+        await Server.WaitPost(() =>
+        {
+            Assert.That(HandSys.TryDrop(Player, handsComp: Hands));
+        });
+
+        await RunTicks(1);
+        Assert.IsNull(Hands.ActiveHandEntity);
+    }
+
+    /// <summary>
+    /// Use the currently held entity.
+    /// </summary>
+    protected async Task UseInHand()
+    {
+        if (Hands.ActiveHandEntity is not {} target)
+        {
+            Assert.Fail("Not holding any entity");
+            return;
+        }
+
+        await Server.WaitPost(() =>
+        {
+            InteractSys.UserInteraction(Player, SEntMan.GetComponent<TransformComponent>(target).Coordinates, target);
+        });
+    }
+
+    /// <summary>
+    /// Place an entity prototype into the players hand and interact with the given entity (or target position)
+    /// </summary>
+    protected async Task Interact(string? id, int quantity = 1, bool shouldSucceed = true, bool awaitDoAfters = true)
+        => await Interact(id == null ? null : (id, quantity), shouldSucceed, awaitDoAfters);
+
+    /// <summary>
+    /// Place an entity prototype into the players hand and interact with the given entity (or target position)
+    /// </summary>
+    protected async Task Interact(EntitySpecifier? entity, bool shouldSucceed = true, bool awaitDoAfters = true)
+    {
+        // For every interaction, we will also examine the entity, just in case this breaks something, somehow.
+        // (e.g., servers attempt to assemble construction examine hints).
+        if (Target != null)
+        {
+            await Client.WaitPost(() => ExamineSys.DoExamine(Target.Value));
+        }
+
+        await PlaceInHands(entity);
+
+        if (Target == null || !Target.Value.IsClientSide())
+        {
+            await Server.WaitPost(() => InteractSys.UserInteraction(Player, TargetCoords, Target));
+            await RunTicks(1);
+        }
+        else
+        {
+            // The entity is client-side, so attempt to start construction
+            var ghost = CEntMan.GetComponent<ConstructionGhostComponent>(Target.Value);
+            await Client.WaitPost(() => CConSys.TryStartConstruction(ghost.GhostId));
+            await RunTicks(5);
+        }
+
+        if (awaitDoAfters)
+            await AwaitDoAfters(shouldSucceed);
+
+        await CheckTargetChange(shouldSucceed && awaitDoAfters);
+    }
+
+    /// <summary>
+    /// Wait for any currently active DoAfters to finish.
+    /// </summary>
+    protected async Task AwaitDoAfters(bool shouldSucceed = true, int maxExpected = 1)
+    {
+        if (!ActiveDoAfters.Any())
+            return;
+
+        // Generally expect interactions to only start one DoAfter.
+        Assert.That(ActiveDoAfters.Count(), Is.LessThanOrEqualTo(maxExpected));
+
+        // wait out the DoAfters.
+        var doAfters = ActiveDoAfters.ToList();
+        while (ActiveDoAfters.Any())
+        {
+            await RunTicks(10);
+        }
+
+        if (!shouldSucceed)
+            return;
+
+        foreach (var doAfter in doAfters)
+        {
+            Assert.That(!doAfter.Cancelled);
+        }
+    }
+
+    /// <summary>
+    /// Cancel any currently active DoAfters. Default arguments are such that it also checks that there is at least one
+    /// active DoAfter to cancel.
+    /// </summary>
+    protected async Task CancelDoAfters(int minExpected = 1, int maxExpected = 1)
+    {
+        Assert.That(ActiveDoAfters.Count(), Is.GreaterThanOrEqualTo(minExpected));
+        Assert.That(ActiveDoAfters.Count(), Is.LessThanOrEqualTo(maxExpected));
+
+        if (!ActiveDoAfters.Any())
+            return;
+
+        // Cancel all the do-afters
+        var doAfters = ActiveDoAfters.ToList();
+        await Server.WaitPost(() =>
+        {
+            foreach (var doAfter in doAfters)
+            {
+                DoAfterSys.Cancel(Player, doAfter.Index, DoAfters);
+            }
+        });
+
+        await RunTicks(1);
+
+        foreach (var doAfter in doAfters)
+        {
+            Assert.That(doAfter.Cancelled);
+        }
+
+        Assert.That(ActiveDoAfters.Count(), Is.EqualTo(0));
+    }
+
+    /// <summary>
+    /// Check if the test's target entity has changed. E.g., construction interactions will swap out entities while
+    /// a structure is being built.
+    /// </summary>
+    protected async Task CheckTargetChange(bool shouldSucceed)
+    {
+        EntityUid newTarget = default;
+        if (Target == null)
+            return;
+        var target = Target.Value;
+
+        await RunTicks(5);
+
+        if (target.IsClientSide())
+        {
+            Assert.That(CEntMan.Deleted(target), Is.EqualTo(shouldSucceed),
+                $"Construction ghost was {(shouldSucceed ? "not deleted" : "deleted")}.");
+
+            if (shouldSucceed)
+            {
+                Assert.That(CTestSystem.Ghosts.TryGetValue(ConstructionGhostId, out newTarget),
+                    $"Failed to get construction entity from ghost Id");
+
+                await Client.WaitPost(() => Logger.Debug($"Construction ghost {ConstructionGhostId} became entity {newTarget}"));
+                Target = newTarget;
+            }
+        }
+
+        if (STestSystem.EntChanges.TryGetValue(Target.Value, out newTarget))
+        {
+            await Server.WaitPost(
+                () => Logger.Debug($"Construction entity {Target.Value} changed to {newTarget}"));
+
+            Target = newTarget;
+        }
+
+        if (Target != target)
+            await CheckTargetChange(shouldSucceed);
+    }
+
+    /// <summary>
+    /// Variant of <see cref="InteractUsing"/> that performs several interactions using different entities.
+    /// </summary>
+    protected async Task Interact(params EntitySpecifier?[] specifiers)
+    {
+        foreach (var spec in specifiers)
+        {
+            await Interact(spec);
+        }
+    }
+
+    #region Asserts
+
+    protected void AssertPrototype(string? prototype)
+    {
+        var meta = Comp<MetaDataComponent>();
+        Assert.That(meta.EntityPrototype?.ID, Is.EqualTo(prototype));
+    }
+
+    protected void AssertAnchored(bool anchored = true)
+    {
+        var sXform = SEntMan.GetComponent<TransformComponent>(Target!.Value);
+        var cXform = CEntMan.GetComponent<TransformComponent>(Target.Value);
+        Assert.That(sXform.Anchored, Is.EqualTo(anchored));
+        Assert.That(cXform.Anchored, Is.EqualTo(anchored));
+    }
+
+    protected void AssertDeleted(bool deleted = true)
+    {
+        Assert.That(SEntMan.Deleted(Target), Is.EqualTo(deleted));
+        Assert.That(CEntMan.Deleted(Target), Is.EqualTo(deleted));
+    }
+
+    /// <summary>
+    /// Assert whether or not the target has the given component.
+    /// </summary>
+    protected void AssertComp<T>(bool hasComp = true)
+    {
+        Assert.That(SEntMan.HasComponent<T>(Target), Is.EqualTo(hasComp));
+    }
+
+    /// <summary>
+    /// Check that the tile at the target position matches some prototype.
+    /// </summary>
+    protected async Task AssertTile(string? proto, EntityCoordinates? coords = null)
+    {
+        var targetTile = proto == null
+            ? Tile.Empty
+            : new Tile(TileMan[proto].TileId);
+
+        Tile tile = Tile.Empty;
+        var pos = (coords ?? TargetCoords).ToMap(SEntMan, Transform);
+        await Server.WaitPost(() =>
+        {
+            if (MapMan.TryFindGridAt(pos, out var grid))
+                tile = grid.GetTileRef(coords ?? TargetCoords).Tile;
+        });
+
+        Assert.That(tile.TypeId, Is.EqualTo(targetTile.TypeId));
+    }
+
+    #endregion
+
+    #region Entity lookups
+
+    /// <summary>
+    /// Returns entities in an area around the target. Ignores the map, grid, player, target, and contained entities.
+    /// </summary>
+    protected async Task<HashSet<EntityUid>> DoEntityLookup(LookupFlags flags = LookupFlags.Uncontained)
+    {
+        var lookup = SEntMan.System<EntityLookupSystem>();
+
+        HashSet<EntityUid> entities = default!;
+        await Server.WaitPost(() =>
+        {
+            // Get all entities left behind by deconstruction
+            entities = lookup.GetEntitiesIntersecting(MapId, Box2.CentredAroundZero((10, 10)), flags);
+
+            var xformQuery = SEntMan.GetEntityQuery<TransformComponent>();
+
+            HashSet<EntityUid> toRemove = new();
+            foreach (var ent in entities)
+            {
+                var transform = xformQuery.GetComponent(ent);
+
+                if (ent == transform.MapUid
+                    || ent == transform.GridUid
+                    || ent == Player
+                    || ent == Target)
+                {
+                    toRemove.Add(ent);
+                }
+            }
+
+            entities.ExceptWith(toRemove);
+        });
+
+        return entities;
+    }
+
+    /// <summary>
+    /// Performs an entity lookup and asserts that only the listed entities exist and that they are all present.
+    /// Ignores the grid, map, player, target and contained entities.
+    /// </summary>
+    protected async Task AssertEntityLookup(params EntitySpecifier[] entities)
+    {
+        var collection = new EntitySpecifierCollection(entities);
+        await AssertEntityLookup(collection);
+    }
+
+    /// <summary>
+    /// Performs an entity lookup and asserts that only the listed entities exist and that they are all present.
+    /// Ignores the grid, map, player, target and contained entities.
+    /// </summary>
+    protected async Task AssertEntityLookup(
+        EntitySpecifierCollection collection,
+        bool failOnMissing = true,
+        bool failOnExcess = true,
+        LookupFlags flags = LookupFlags.Uncontained)
+    {
+        var expected = collection.Clone();
+        var entities = await DoEntityLookup(flags);
+        var found = ToEntityCollection(entities);
+        expected.Remove(found);
+        expected.ConvertToStacks(ProtoMan, Factory);
+
+        if (expected.Entities.Count == 0)
+            return;
+
+        Assert.Multiple(() =>
+        {
+            foreach (var (proto, quantity) in expected.Entities)
+            {
+                if (quantity < 0 && failOnExcess)
+                    Assert.Fail($"Unexpected entity/stack: {proto}, quantity: {-quantity}");
+
+                if (quantity > 0 && failOnMissing)
+                    Assert.Fail($"Missing entity/stack: {proto}, quantity: {quantity}");
+
+                if (quantity == 0)
+                    throw new Exception("Error in entity collection math.");
+            }
+        });
+    }
+
+    /// <summary>
+    /// Performs an entity lookup and attempts to find an entity matching the given entity specifier.
+    /// </summary>
+    /// <remarks>
+    /// This is used to check that an item-crafting attempt was successful. Ideally crafting items would just return the
+    /// entity or raise an event or something.
+    /// </remarks>
+    protected async Task<EntityUid> FindEntity(
+        EntitySpecifier spec,
+        LookupFlags flags = LookupFlags.Uncontained | LookupFlags.Contained,
+        bool shouldSucceed = true)
+    {
+        spec.ConvertToStack(ProtoMan, Factory);
+
+        var entities = await DoEntityLookup(flags);
+        foreach (var uid in entities)
+        {
+            var found = ToEntitySpecifier(uid);
+            if (spec.Prototype != found.Prototype)
+                continue;
+
+            if (found.Quantity >= spec.Quantity)
+                return uid;
+
+            // TODO combine stacks?
+        }
+
+        if (shouldSucceed)
+            Assert.Fail($"Could not find stack/entity with prototype {spec.Prototype}");
+
+        return default;
+    }
+
+    #endregion
+
+
+    /// <summary>
+    /// List of currently active DoAfters on the player.
+    /// </summary>
+    protected IEnumerable<Shared.DoAfter.DoAfter> ActiveDoAfters
+        => DoAfters.DoAfters.Values.Where(x => !x.Cancelled && !x.Completed);
+
+    /// <summary>
+    /// Convenience method to get components on the target. Returns SERVER-SIDE components.
+    /// </summary>
+    protected T Comp<T>() => SEntMan.GetComponent<T>(Target!.Value);
+
+    /// <summary>
+    /// Set the tile at the target position to some prototype.
+    /// </summary>
+    protected async Task SetTile(string? proto, EntityCoordinates? coords = null, MapGridComponent? grid = null)
+    {
+        var tile = proto == null
+            ? Tile.Empty
+            : new Tile(TileMan[proto].TileId);
+
+        var pos = (coords ?? TargetCoords).ToMap(SEntMan, Transform);
+
+        await Server.WaitPost(() =>
+        {
+            if (grid != null || MapMan.TryFindGridAt(pos, out grid))
+            {
+                grid.SetTile(coords ?? TargetCoords, tile);
+                return;
+            }
+
+            if (proto == null)
+                return;
+
+            grid = MapMan.CreateGrid(MapData.MapId);
+            var gridXform = SEntMan.GetComponent<TransformComponent>(grid.Owner);
+            Transform.SetWorldPosition(gridXform, pos.Position);
+            grid.SetTile(coords ?? TargetCoords, tile);
+
+            if (!MapMan.TryFindGridAt(pos, out grid))
+                Assert.Fail("Failed to create grid?");
+        });
+        await AssertTile(proto, coords);
+    }
+
+    protected async Task Delete(EntityUid  uid)
+    {
+        await Server.WaitPost(() => SEntMan.DeleteEntity(uid));
+        await RunTicks(5);
+    }
+
+    protected async Task RunTicks(int ticks)
+    {
+        await PoolManager.RunTicksSync(PairTracker.Pair, ticks);
+    }
+
+    protected async Task RunSeconds(float seconds)
+        => await RunTicks((int) Math.Ceiling(seconds / TickPeriod));
+}

Content.IntegrationTests/Tests/Interaction/InteractionTest.cs

@@ -0,0 +1,198 @@
+#nullable enable
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Client.Construction;
+using Content.Client.Examine;
+using Content.Server.Body.Systems;
+using Content.Server.Mind.Components;
+using Content.Server.Stack;
+using Content.Server.Tools;
+using Content.Shared.Body.Part;
+using Content.Shared.DoAfter;
+using Content.Shared.Hands.Components;
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+using Robust.UnitTesting;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+/// <summary>
+/// This is a base class designed to make it easier to test various interactions like construction & DoAfters.
+///
+/// For construction tests, the interactions are intentionally hard-coded and not pulled automatically from the
+/// construction graph, even though this may be a pain to maintain. This is because otherwise these tests could not
+/// detect errors in the graph pathfinding (e.g., infinite loops, missing steps, etc).
+/// </summary>
+[TestFixture]
+[FixtureLifeCycle(LifeCycle.InstancePerTestCase)]
+public abstract partial class InteractionTest
+{
+    protected PairTracker PairTracker = default!;
+    protected TestMapData MapData = default!;
+
+    protected RobustIntegrationTest.ServerIntegrationInstance Server => PairTracker.Pair.Server;
+    protected RobustIntegrationTest.ClientIntegrationInstance Client => PairTracker.Pair.Client;
+
+    protected MapId MapId => MapData.MapId;
+
+    /// <summary>
+    /// Target coordinates. Note that this does not necessarily correspond to the position of the <see cref="Target"/>
+    /// entity.
+    /// </summary>
+    protected EntityCoordinates TargetCoords;
+
+    /// <summary>
+    /// Initial player coordinates. Note that this does not necessarily correspond to the position of the
+    /// <see cref="Player"/> entity.
+    /// </summary>
+    protected EntityCoordinates PlayerCoords;
+
+    /// <summary>
+    /// The player entity that performs all these interactions. Defaults to an admin-observer with 1 hand.
+    /// </summary>
+    protected EntityUid Player;
+
+    /// <summary>
+    /// The current target entity. This is the default entity for various helper functions.
+    /// </summary>
+    /// <remarks>
+    /// Note that this target may be automatically modified by various interactions, in particular construction
+    /// interactions often swap out entities, and there are helper methods that attempt to automatically upddate
+    /// the target entity. See <see cref="CheckTargetChange"/>
+    /// </remarks>
+    protected EntityUid? Target;
+
+    /// <summary>
+    /// When attempting to start construction, this is the client-side ID of the construction ghost.
+    /// </summary>
+    protected int ConstructionGhostId;
+
+    // SERVER dependencies
+    protected IEntityManager SEntMan = default!;
+    protected ITileDefinitionManager TileMan = default!;
+    protected IMapManager MapMan = default!;
+    protected IPrototypeManager ProtoMan = default!;
+    protected IGameTiming Timing = default!;
+    protected IComponentFactory Factory = default!;
+    protected SharedHandsSystem HandSys = default!;
+    protected StackSystem Stack = default!;
+    protected SharedInteractionSystem InteractSys = default!;
+    protected Content.Server.Construction.ConstructionSystem SConstruction = default!;
+    protected SharedDoAfterSystem DoAfterSys = default!;
+    protected ToolSystem ToolSys = default!;
+    protected InteractionTestSystem STestSystem = default!;
+    protected SharedTransformSystem Transform = default!;
+
+    // CLIENT dependencies
+    protected IEntityManager CEntMan = default!;
+    protected ConstructionSystem CConSys = default!;
+    protected ExamineSystem ExamineSys = default!;
+    protected InteractionTestSystem CTestSystem = default!;
+
+    // player components
+    protected HandsComponent Hands = default!;
+    protected DoAfterComponent DoAfters = default!;
+
+    public float TickPeriod => (float)Timing.TickPeriod.TotalSeconds;
+
+    [SetUp]
+    public async Task Setup()
+    {
+        PairTracker = await PoolManager.GetServerClient(new PoolSettings());
+
+        // server dependencies
+        SEntMan = Server.ResolveDependency<IEntityManager>();
+        TileMan = Server.ResolveDependency<ITileDefinitionManager>();
+        MapMan = Server.ResolveDependency<IMapManager>();
+        ProtoMan = Server.ResolveDependency<IPrototypeManager>();
+        Factory = Server.ResolveDependency<IComponentFactory>();
+        Timing = Server.ResolveDependency<IGameTiming>();
+        HandSys = SEntMan.System<SharedHandsSystem>();
+        InteractSys = SEntMan.System<SharedInteractionSystem>();
+        ToolSys = SEntMan.System<ToolSystem>();
+        DoAfterSys = SEntMan.System<SharedDoAfterSystem>();
+        Transform = SEntMan.System<SharedTransformSystem>();
+        SConstruction = SEntMan.System<Content.Server.Construction.ConstructionSystem>();
+        STestSystem = SEntMan.System<InteractionTestSystem>();
+        Stack = SEntMan.System<StackSystem>();
+
+        // client dependencies
+        CEntMan = Client.ResolveDependency<IEntityManager>();
+        CTestSystem = CEntMan.System<InteractionTestSystem>();
+        CConSys = CEntMan.System<ConstructionSystem>();
+        ExamineSys = CEntMan.System<ExamineSystem>();
+
+        // Setup map.
+        MapData = await PoolManager.CreateTestMap(PairTracker);
+        PlayerCoords = MapData.GridCoords.Offset((0.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan);
+        TargetCoords = MapData.GridCoords.Offset((1.5f, 0.5f)).WithEntityId(MapData.MapUid, Transform, SEntMan);
+        await SetTile(Plating, grid: MapData.MapGrid);
+
+        // Get player data
+        var sPlayerMan = Server.ResolveDependency<Robust.Server.Player.IPlayerManager>();
+        var cPlayerMan = Client.ResolveDependency<Robust.Client.Player.IPlayerManager>();
+        if (cPlayerMan.LocalPlayer?.Session == null)
+            Assert.Fail("No player");
+        var cSession = cPlayerMan.LocalPlayer!.Session!;
+        var sSession = sPlayerMan.GetSessionByUserId(cSession.UserId);
+
+        // Spawn player entity & attach
+        EntityUid? old = default;
+        await Server.WaitPost(() =>
+        {
+            old = cPlayerMan.LocalPlayer.ControlledEntity;
+            Player = SEntMan.SpawnEntity(PlayerEntity, PlayerCoords);
+            sSession.AttachToEntity(Player);
+            Hands = SEntMan.GetComponent<HandsComponent>(Player);
+            DoAfters = SEntMan.GetComponent<DoAfterComponent>(Player);
+        });
+
+        // Check player got attached.
+        await RunTicks(5);
+        Assert.That(cPlayerMan.LocalPlayer.ControlledEntity, Is.EqualTo(Player));
+
+        // Delete old player entity.
+        await Server.WaitPost(() =>
+        {
+            if (old == null)
+                return;
+
+            // Fuck you mind system I want an hour of my life back
+            if (SEntMan.TryGetComponent(old, out MindComponent? mind))
+                mind.GhostOnShutdown = false;
+
+            SEntMan.DeleteEntity(old.Value);
+        });
+
+        // Ensure that the player only has one hand, so that they do not accidentally pick up deconstruction protucts
+        await Server.WaitPost(() =>
+        {
+            var bodySystem = SEntMan.System<BodySystem>();
+            var hands = bodySystem.GetBodyChildrenOfType(Player, BodyPartType.Hand).ToArray();
+
+            for (var i = 1; i < hands.Length; i++)
+            {
+                bodySystem.DropPart(hands[i].Id);
+                SEntMan.DeleteEntity(hands[i].Id);
+            }
+        });
+
+        // Final player asserts/checks.
+        await PoolManager.ReallyBeIdle(PairTracker.Pair, 5);
+        Assert.That(cPlayerMan.LocalPlayer.ControlledEntity, Is.EqualTo(Player));
+        Assert.That(sPlayerMan.GetSessionByUserId(cSession.UserId).AttachedEntity, Is.EqualTo(Player));
+    }
+
+    [TearDown]
+    public async Task Cleanup()
+    {
+        await Server.WaitPost(() => MapMan.DeleteMap(MapId));
+        await PairTracker.CleanReturnAsync();
+    }
+}
+

Content.IntegrationTests/Tests/Interaction/InteractionTestSystem.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using Content.Server.Construction;
+using Content.Shared.Construction;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Interaction;
+
+/// <summary>
+///     System for listening to events that get raised when construction entities change.
+///     In particular, when construction ghosts become real entities, and when existing entities get replaced with
+///     new ones.
+/// </summary>
+public sealed class InteractionTestSystem : EntitySystem
+{
+    public Dictionary<int, EntityUid> Ghosts = new();
+    public Dictionary<EntityUid, EntityUid> EntChanges = new();
+
+    public override void Initialize()
+    {
+        SubscribeNetworkEvent<AckStructureConstructionMessage>(OnAck);
+        SubscribeLocalEvent<ConstructionChangeEntityEvent>(OnEntChange);
+    }
+
+    private void OnEntChange(ConstructionChangeEntityEvent ev)
+    {
+        EntChanges[ev.Old] = ev.New;
+    }
+
+    private void OnAck(AckStructureConstructionMessage ev)
+    {
+        if (ev.Uid != null)
+            Ghosts[ev.GhostId] = ev.Uid.Value;
+    }
+}

Content.IntegrationTests/Tests/Payload/ModularGrenadeTests.cs

@@ -0,0 +1,76 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Explosion.Components;
+using NUnit.Framework;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+
+namespace Content.IntegrationTests.Tests.Payload;
+
+public sealed class ModularGrenadeTests : InteractionTest
+{
+    public const string Trigger = "TimerTrigger";
+    public const string Payload = "ExplosivePayload";
+
+    /// <summary>
+    /// Test that a modular grenade can be fully crafted and detonated.
+    /// </summary>
+    [Test]
+    public async Task AssembleAndDetonateGrenade()
+    {
+        await PlaceInHands(Steel, 5);
+        await CraftItem("ModularGrenadeRecipe");
+        Target = await FindEntity("ModularGrenade");
+
+        await Drop();
+        await Interact(Cable);
+
+        // Insert & remove trigger
+        AssertComp<OnUseTimerTriggerComponent>(false);
+        await Interact(Trigger);
+        AssertComp<OnUseTimerTriggerComponent>();
+        await FindEntity(Trigger, LookupFlags.Uncontained, shouldSucceed: false);
+        await Interact(Pry);
+        AssertComp<OnUseTimerTriggerComponent>(false);
+
+        // Trigger was dropped to floor, not deleted.
+        await FindEntity(Trigger, LookupFlags.Uncontained);
+
+        // Re-insert
+        await Interact(Trigger);
+        AssertComp<OnUseTimerTriggerComponent>();
+
+        // Insert & remove payload.
+        await Interact(Payload);
+        await FindEntity(Payload, LookupFlags.Uncontained, shouldSucceed: false);
+        await Interact(Pry);
+        var ent = await FindEntity(Payload, LookupFlags.Uncontained);
+        await Delete(ent);
+
+        // successfully insert a second time
+        await Interact(Payload);
+        ent = await FindEntity(Payload);
+        var sys = SEntMan.System<SharedContainerSystem>();
+        Assert.That(sys.IsEntityInContainer(ent));
+
+        // Activate trigger.
+        await Pickup();
+        AssertComp<ActiveTimerTriggerComponent>(false);
+        await UseInHand();
+
+        // So uhhh grenades in hands don't destroy themselves when exploding. Maybe that will be fixed eventually.
+        await Drop();
+
+        // Wait until grenade explodes
+        var timer = Comp<ActiveTimerTriggerComponent>();
+        while (timer.TimeRemaining >= 0)
+        {
+            await RunTicks(10);
+        }
+
+        // Grenade has exploded.
+        await RunTicks(5);
+        AssertDeleted();
+    }
+}
+

Content.IntegrationTests/Tests/Tiles/TileConstructionTests.cs

@@ -0,0 +1,121 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using NUnit.Framework;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+
+namespace Content.IntegrationTests.Tests.Tiles;
+
+public sealed class TileConstructionTests : InteractionTest
+{
+    private void AssertGridCount(int value)
+    {
+        var count = 0;
+        var query = SEntMan.AllEntityQueryEnumerator<MapGridComponent, TransformComponent>();
+        while (query.MoveNext(out _, out var xform))
+        {
+            if (xform.MapUid == MapData.MapUid)
+                count++;
+        }
+
+        Assert.That(count, Is.EqualTo(value));
+    }
+
+    /// <summary>
+    /// Test placing and cutting a single lattice.
+    /// </summary>
+    [Test]
+    public async Task PlaceThenCutLattice()
+    {
+        await AssertTile(Plating);
+        await AssertTile(Plating, PlayerCoords);
+        AssertGridCount(1);
+        await SetTile(null);
+        await Interact(Rod);
+        await AssertTile(Lattice);
+        Assert.IsNull(Hands.ActiveHandEntity);
+        await Interact(Cut);
+        await AssertTile(null);
+        await AssertEntityLookup((Rod, 1));
+        AssertGridCount(1);
+    }
+
+    /// <summary>
+    /// Test placing and cutting a single lattice in space (not adjacent to any existing grid.
+    /// </summary>
+    [Test]
+    public async Task CutThenPlaceLatticeNewGrid()
+    {
+        await AssertTile(Plating);
+        await AssertTile(Plating, PlayerCoords);
+        AssertGridCount(1);
+
+        // Remove grid
+        await SetTile(null);
+        await SetTile(null, PlayerCoords);
+        Assert.That(MapData.MapGrid.Deleted);
+        AssertGridCount(0);
+
+        // Place Lattice
+        var oldPos = TargetCoords;
+        TargetCoords = new EntityCoordinates(MapData.MapUid, 1, 0);
+        await Interact(Rod);
+        TargetCoords = oldPos;
+        await AssertTile(Lattice);
+        AssertGridCount(1);
+
+        // Cut lattice
+        Assert.IsNull(Hands.ActiveHandEntity);
+        await Interact(Cut);
+        await AssertTile(null);
+        AssertGridCount(0);
+
+        await AssertEntityLookup((Rod, 1));
+    }
+
+    /// <summary>
+    /// Test space -> floor -> plating
+    /// </summary>
+    [Test]
+    public async Task FloorConstructDeconstruct()
+    {
+        await AssertTile(Plating);
+        await AssertTile(Plating, PlayerCoords);
+        AssertGridCount(1);
+
+        // Remove grid
+        await SetTile(null);
+        await SetTile(null, PlayerCoords);
+        Assert.That(MapData.MapGrid.Deleted);
+        AssertGridCount(0);
+
+        // Space -> Lattice
+        var oldPos = TargetCoords;
+        TargetCoords = new EntityCoordinates(MapData.MapUid, 1, 0);
+        await Interact(Rod);
+        TargetCoords = oldPos;
+        await AssertTile(Lattice);
+        AssertGridCount(1);
+
+        // Lattice -> Plating
+        await Interact(Steel);
+        Assert.IsNull(Hands.ActiveHandEntity);
+        await AssertTile(Plating);
+        AssertGridCount(1);
+
+        // Plating -> Tile
+        await Interact(FloorItem);
+        Assert.IsNull(Hands.ActiveHandEntity);
+        await AssertTile(Floor);
+        AssertGridCount(1);
+
+        // Tile -> Plating
+        await Interact(Pry);
+        await AssertTile(Plating);
+        AssertGridCount(1);
+
+        await AssertEntityLookup((FloorItem, 1));
+    }
+}
+

Content.IntegrationTests/Tests/Weldable/WeldableTests.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using Content.IntegrationTests.Tests.Interaction;
+using Content.Server.Tools.Components;
+using NUnit.Framework;
+
+namespace Content.IntegrationTests.Tests.Weldable;
+
+/// <summary>
+///  Simple test to check that using a welder on a locker will weld it shut.
+/// </summary>
+public sealed class WeldableTests : InteractionTest
+{
+    public const string Locker = "LockerFreezer";
+
+    [Test]
+    public async Task WeldLocker()
+    {
+        await SpawnTarget(Locker);
+        var comp = Comp<WeldableComponent>();
+
+        Assert.That(comp.Weldable, Is.True);
+        Assert.That(comp.IsWelded, Is.False);
+
+        await Interact(Weld);
+        Assert.That(comp.IsWelded, Is.True);
+        AssertPrototype(Locker); // Prototype did not change.
+    }
+}

Content.Server/Construction/Completions/BuildComputer.cs

@@ -13,6 +13,7 @@ namespace Content.Server.Construction.Completions
     {
         [DataField("container")] public string Container { get; private set; } = string.Empty;
 
+        // TODO use or generalize ConstructionSystem.ChangeEntity();
         public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
         {
             if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
@@ -62,8 +63,12 @@ namespace Content.Server.Construction.Completions
             // We only add this container. If some construction needs to take other containers into account, fix this.
             entityManager.EntitySysManager.GetEntitySystem<ConstructionSystem>().AddContainer(computer, Container);
 
+            var entChangeEv = new ConstructionChangeEntityEvent(computer, uid);
+            entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+            entityManager.EventBus.RaiseLocalEvent(computer, entChangeEv, broadcast: true);
+
             // Delete the original entity.
-            entityManager.DeleteEntity(uid);
+            entityManager.QueueDeleteEntity(uid);
         }
     }
 }

Content.Server/Construction/Completions/BuildMachine.cs

@@ -12,6 +12,7 @@ namespace Content.Server.Construction.Completions
     [DataDefinition]
     public sealed class BuildMachine : IGraphAction
     {
+        // TODO use or generalize ConstructionSystem.ChangeEntity();
         public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
         {
             if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
@@ -102,7 +103,10 @@ namespace Content.Server.Construction.Completions
                 constructionSystem.RefreshParts(machineComp);
             }
 
-            entityManager.DeleteEntity(uid);
+            var entChangeEv = new ConstructionChangeEntityEvent(machine, uid);
+            entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+            entityManager.EventBus.RaiseLocalEvent(machine, entChangeEv, broadcast: true);
+            entityManager.QueueDeleteEntity(uid);
         }
     }
 }

Content.Server/Construction/Completions/BuildMech.cs

@@ -23,6 +23,7 @@ public sealed class BuildMech : IGraphAction
     [DataField("container")]
     public string Container = "battery-container";
 
+    // TODO use or generalize ConstructionSystem.ChangeEntity();
     public void PerformAction(EntityUid uid, EntityUid? userUid, IEntityManager entityManager)
     {
         if (!entityManager.TryGetComponent(uid, out ContainerManagerComponent? containerManager))
@@ -64,8 +65,10 @@ public sealed class BuildMech : IGraphAction
             mechComp.BatterySlot.Insert(cell);
         }
 
-        // Delete the original entity.
+        var entChangeEv = new ConstructionChangeEntityEvent(mech, uid);
-        entityManager.DeleteEntity(uid);
+        entityManager.EventBus.RaiseLocalEvent(uid, entChangeEv);
+        entityManager.EventBus.RaiseLocalEvent(mech, entChangeEv, broadcast: true);
+        entityManager.QueueDeleteEntity(uid);
     }
 }
 

Content.Server/Construction/ConstructionSystem.Graph.cs

@@ -352,6 +352,10 @@ namespace Content.Server.Construction
                 }
             }
 
+            var entChangeEv = new ConstructionChangeEntityEvent(newUid, uid);
+            RaiseLocalEvent(uid, entChangeEv);
+            RaiseLocalEvent(newUid, entChangeEv, broadcast: true);
+
             QueueDel(uid);
 
             return newUid;
@@ -384,4 +388,20 @@ namespace Content.Server.Construction
             return ChangeNode(uid, userUid, nodeId, performActions, construction);
         }
     }
+
+    /// <summary>
+    ///     This event gets raised when an entity changes prototype / uid during construction. The event is raised
+    ///     directed both at the old and new entity.
+    /// </summary>
+    public sealed class ConstructionChangeEntityEvent : EntityEventArgs
+    {
+        public readonly EntityUid New;
+        public readonly EntityUid Old;
+
+        public ConstructionChangeEntityEvent(EntityUid newUid, EntityUid oldUid)
+        {
+            New = newUid;
+            Old = oldUid;
+        }
+    }
 }

Content.Server/Construction/ConstructionSystem.Initial.cs

@@ -169,6 +169,8 @@ namespace Content.Server.Construction
                             if (!materialStep.EntityValid(entity, out var stack))
                                 continue;
 
+                            // TODO allow taking from several stacks.
+                            // Also update crafting steps to check if it works.
                             var splitStack = _stackSystem.Split(entity, materialStep.Amount, user.ToCoordinates(0, 0), stack);
 
                             if (splitStack == null)
@@ -288,43 +290,49 @@ namespace Content.Server.Construction
             return newEntity;
         }
 
-        // LEGACY CODE. See warning at the top of the file!
         private async void HandleStartItemConstruction(TryStartItemConstructionMessage ev, EntitySessionEventArgs args)
         {
-            if (!_prototypeManager.TryIndex(ev.PrototypeName, out ConstructionPrototype? constructionPrototype))
+            if (args.SenderSession.AttachedEntity is {Valid: true} user)
+                await TryStartItemConstruction(ev.PrototypeName, user);
+        }
+
+        // LEGACY CODE. See warning at the top of the file!
+        public async Task<bool> TryStartItemConstruction(string prototype, EntityUid user)
         {
-                _sawmill.Error($"Tried to start construction of invalid recipe '{ev.PrototypeName}'!");
+            if (!_prototypeManager.TryIndex(prototype, out ConstructionPrototype? constructionPrototype))
-                return;
+            {
+                _sawmill.Error($"Tried to start construction of invalid recipe '{prototype}'!");
+                return false;
             }
 
             if (!_prototypeManager.TryIndex(constructionPrototype.Graph,
                     out ConstructionGraphPrototype? constructionGraph))
             {
                 _sawmill.Error(
-                    $"Invalid construction graph '{constructionPrototype.Graph}' in recipe '{ev.PrototypeName}'!");
+                    $"Invalid construction graph '{constructionPrototype.Graph}' in recipe '{prototype}'!");
-                return;
+                return false;
             }
 
             var startNode = constructionGraph.Nodes[constructionPrototype.StartNode];
             var targetNode = constructionGraph.Nodes[constructionPrototype.TargetNode];
             var pathFind = constructionGraph.Path(startNode.Name, targetNode.Name);
 
-            if (args.SenderSession.AttachedEntity is not {Valid: true} user || !_actionBlocker.CanInteract(user, null))
+            if (!_actionBlocker.CanInteract(user, null))
-                return;
+                return false;
 
             if (!HasComp<HandsComponent>(user))
-                return;
+                return false;
 
             foreach (var condition in constructionPrototype.Conditions)
             {
                 if (!condition.Condition(user, user.ToCoordinates(0, 0), Direction.South))
-                    return;
+                    return false;
             }
 
             if (pathFind == null)
             {
                 throw new InvalidDataException(
-                    $"Can't find path from starting node to target node in construction! Recipe: {ev.PrototypeName}");
+                    $"Can't find path from starting node to target node in construction! Recipe: {prototype}");
             }
 
             var edge = startNode.GetEdge(pathFind[0].Name);
@@ -332,7 +340,7 @@ namespace Content.Server.Construction
             if (edge == null)
             {
                 throw new InvalidDataException(
-                    $"Can't find edge from starting node to the next node in pathfinding! Recipe: {ev.PrototypeName}");
+                    $"Can't find edge from starting node to the next node in pathfinding! Recipe: {prototype}");
             }
 
             // No support for conditions here!
@@ -347,11 +355,12 @@ namespace Content.Server.Construction
             }
 
             if (await Construct(user, "item_construction", constructionGraph, edge, targetNode) is not { Valid: true } item)
-                return;
+                return false;
 
             // Just in case this is a stack, attempt to merge it. If it isn't a stack, this will just normally pick up
             // or drop the item as normal.
             _stackSystem.TryMergeToHands(item, user);
+            return true;
         }
 
         // LEGACY CODE. See warning at the top of the file!
@@ -490,7 +499,7 @@ namespace Content.Server.Construction
             xform.LocalRotation = constructionPrototype.CanRotate ? ev.Angle : Angle.Zero;
             xform.Anchored = wasAnchored;
 
-            RaiseNetworkEvent(new AckStructureConstructionMessage(ev.Ack));
+            RaiseNetworkEvent(new AckStructureConstructionMessage(ev.Ack, structure));
             _adminLogger.Add(LogType.Construction, LogImpact.Low, $"{ToPrettyString(user):player} has turned a {ev.PrototypeName} construction ghost into {ToPrettyString(structure)} at {Transform(structure).Coordinates}");
             Cleanup();
         }

Content.Server/Construction/ConstructionSystem.Machine.cs

@@ -59,6 +59,14 @@ public sealed partial class ConstructionSystem
         args.Verbs.Add(verb);
     }
 
+    public List<MachinePartComponent> GetAllParts(EntityUid uid, MachineComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
+            return new List<MachinePartComponent>();
+
+        return GetAllParts(component);
+    }
+
     public List<MachinePartComponent> GetAllParts(MachineComponent component)
     {
         var parts = new List<MachinePartComponent>();

Content.Server/Mind/Components/MindComponent.cs

@@ -31,6 +31,7 @@ namespace Content.Server.Mind.Components
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("ghostOnShutdown")]
+        [Access(typeof(MindSystem), Other = AccessPermissions.ReadWriteExecute)] // FIXME Friends
         public bool GhostOnShutdown { get; set; } = true;
     }
 

Content.Shared/Construction/Events.cs

@@ -64,9 +64,15 @@ public sealed class AckStructureConstructionMessage : EntityEventArgs
 {
     public readonly int GhostId;
 
-    public AckStructureConstructionMessage(int ghostId)
+    /// <summary>
+    ///     The entity that is now being constructed, if any.
+    /// </summary>
+    public readonly EntityUid? Uid;
+
+    public AckStructureConstructionMessage(int ghostId, EntityUid? uid = null)
     {
         GhostId = ghostId;
+        Uid = uid;
     }
 }
 

Content.Shared/DoAfter/DoAfterComponent.cs

@@ -27,7 +27,20 @@ public sealed class DoAfterComponentState : ComponentState
     public DoAfterComponentState(DoAfterComponent component)
     {
         NextId = component.NextId;
+
+        // Cursed test bugs - See CraftingTests.CancelCraft
+        // The following is wrapped in an if DEBUG. This is tests don't (de)serialize net messages and just copy objects
+        // by reference. This means that the server will directly modify cached server states on the client's end.
+        // Crude fix at the moment is to used modified state handling while in debug mode Otherwise, this test cannot work.
+#if !DEBUG
         DoAfters = component.DoAfters;
+#else
+        DoAfters = new();
+        foreach (var (id, doafter) in component.DoAfters)
+        {
+            DoAfters.Add(id, new DoAfter(doafter));
+        }
+#endif
     }
 }
 

Content.Shared/DoAfter/SharedDoAfterSystem.cs

@@ -123,7 +123,6 @@ public abstract partial class SharedDoAfterSystem : EntitySystem
             EnsureComp<ActiveDoAfterComponent>(uid);
     }
 
-
     #region Creation
     /// <summary>
     ///     Tasks that are delayed until the specified time has passed

Content.Shared/Radio/EntitySystems/EncryptionKeySystem.cs

@@ -62,6 +62,7 @@ public sealed class EncryptionKeySystem : EntitySystem
         // TODO add predicted pop-up overrides.
         if (_net.IsServer)
             _popup.PopupEntity(Loc.GetString("encryption-keys-all-extracted"), uid, args.User);
+        
         _audio.PlayPredicted(component.KeyExtractionSound, uid, args.User);
     }
 

Content.Shared/Stacks/StackComponent.cs

@@ -9,7 +9,7 @@ namespace Content.Shared.Stacks
     {
         [ViewVariables(VVAccess.ReadWrite)]
         [DataField("stackType", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<StackPrototype>))]
-        public string? StackTypeId { get; private set; }
+        public string StackTypeId { get; private set; } = default!;
 
         /// <summary>
         ///     Current stack count.