tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make tests faster (#8737)

Browse Source 
* Test changes

* Make finding the test tile a little smarter
This commit is contained in:
wrexbe
2022-06-19 20:22:28 -07:00
committed by GitHub
parent bd54b8de25
commit 81e3b2da88
80 changed files with 1769 additions and 1788 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.github/workflows/build-test-debug.yml vendored
View File

@@ -62,3 +62,8 @@ jobs:
- name: Run Content.Tests - name: Run Content.Tests
run: dotnet test --no-build Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0 run: dotnet test --no-build Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
- name: Run Content.IntegrationTests
shell: pwsh
run: |
$env:DOTNET_gcServer=1
dotnet test --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0

2
Content.Client/Clothing/ClothingSystem.cs
View File

@@ -258,7 +258,7 @@ public sealed class ClothingSystem : EntitySystem
// temporary, until layer draw depths get added. Basically: a layer with the key "slot" is being used as a // temporary, until layer draw depths get added. Basically: a layer with the key "slot" is being used as a
// bookmark to determine where in the list of layers we should insert the clothing layers. // bookmark to determine where in the list of layers we should insert the clothing layers.
bool slotLayerExists = sprite.LayerMapTryGet(slot, out var index); bool slotLayerExists = sprite.LayerMapTryGet(slot, out var index);
// add the new layers // add the new layers
foreach (var (key, layerData) in ev.Layers) foreach (var (key, layerData) in ev.Layers)
{ {

440
Content.IntegrationTests/ContentIntegrationTest.cs
View File

@@ -1,440 +0,0 @@
using System;
using System.Linq;
using System.Threading.Tasks;
using Content.Client.Entry;
using Content.Client.IoC;
using Content.Client.Parallax.Managers;
using Content.Server.GameTicking;
using Content.Server.IoC;
using Content.Shared.CCVar;
using NUnit.Framework;
using Robust.Client;
using Robust.Server;
using Robust.Server.Player;
using Robust.Shared.ContentPack;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.UnitTesting;
namespace Content.IntegrationTests
{
[Parallelizable(ParallelScope.All)]
public abstract class ContentIntegrationTest : RobustIntegrationTest
{
private static readonly (string cvar, string value, bool)[] ServerTestCvars = {
// Avoid funny race conditions with the database.
(CCVars.DatabaseSynchronous.Name, "true", false),
// No artificial database delay, as it can make tests fail.
(CCVars.DatabaseSqliteDelay.Name, "0", false),
// Disable holidays as some of them might mess with the map at round start.
(CCVars.HolidaysEnabled.Name, "false", false),
// Avoid loading a large map by default for integration tests if none has been specified.
(CCVars.GameMap.Name, "empty", true),
// Makes sure IGameMapManager actually listens.
(CCVars.GameMapForced.Name, "true", true),
};
private static void SetServerTestCvars(IntegrationOptions options)
{
foreach (var (cvar, value, tryAdd) in ServerTestCvars)
{
if (tryAdd)
{
options.CVarOverrides.TryAdd(cvar, value);
}
else
{
options.CVarOverrides[cvar] = value;
}
}
}
protected sealed override ClientIntegrationInstance StartClient(ClientIntegrationOptions options = null)
{
options ??= new ClientContentIntegrationOption()
{
FailureLogLevel = LogLevel.Warning
};
options.Pool = ShouldPool(options, false);
// Load content resources, but not config and user data.
options.Options = new GameControllerOptions()
{
LoadContentResources = true,
LoadConfigAndUserData = false,
};
options.ContentStart = true;
options.ContentAssemblies = new[]
{
typeof(Shared.Entry.EntryPoint).Assembly,
typeof(EntryPoint).Assembly,
typeof(ContentIntegrationTest).Assembly
};
options.BeforeStart += () =>
{
IoCManager.Resolve<IModLoader>().SetModuleBaseCallbacks(new ClientModuleTestingCallbacks
{
ClientBeforeIoC = () =>
{
if (options is ClientContentIntegrationOption contentOptions)
{
contentOptions.ContentBeforeIoC?.Invoke();
}
IoCManager.Register<IParallaxManager, DummyParallaxManager>(true);
IoCManager.Resolve<ILogManager>().GetSawmill("loc").Level = LogLevel.Error;
}
});
};
return base.StartClient(options);
}
protected override ServerIntegrationInstance StartServer(ServerIntegrationOptions options = null)
{
options ??= new ServerContentIntegrationOption
{
FailureLogLevel = LogLevel.Warning,
};
SetServerTestCvars(options);
options.Pool = ShouldPool(options, true);
// Load content resources, but not config and user data.
options.Options = new ServerOptions()
{
LoadConfigAndUserData = false,
LoadContentResources = true,
};
options.ContentStart = true;
options.ContentAssemblies = new[]
{
typeof(Shared.Entry.EntryPoint).Assembly,
typeof(Server.Entry.EntryPoint).Assembly,
typeof(ContentIntegrationTest).Assembly
};
options.BeforeStart += () =>
{
IoCManager.Resolve<IModLoader>().SetModuleBaseCallbacks(new ServerModuleTestingCallbacks
{
ServerBeforeIoC = () =>
{
if (options is ServerContentIntegrationOption contentOptions)
{
contentOptions.ContentBeforeIoC?.Invoke();
}
}
});
IoCManager.Resolve<ILogManager>().GetSawmill("loc").Level = LogLevel.Error;
};
return base.StartServer(options);
}
protected ServerIntegrationInstance StartServerDummyTicker(ServerIntegrationOptions options = null)
{
options ??= new ServerContentIntegrationOption();
// Load content resources, but not config and user data.
options.Options = new ServerOptions()
{
LoadConfigAndUserData = false,
LoadContentResources = true,
};
// Dummy game ticker.
options.CVarOverrides[CCVars.GameDummyTicker.Name] = "true";
return StartServer(options);
}
protected async Task<(ClientIntegrationInstance client, ServerIntegrationInstance server)>
StartConnectedServerClientPair(ClientIntegrationOptions clientOptions = null,
ServerIntegrationOptions serverOptions = null)
{
var client = StartClient(clientOptions);
var server = StartServer(serverOptions);
await StartConnectedPairShared(client, server);
return (client, server);
}
protected async Task<(ClientIntegrationInstance client, ServerIntegrationInstance server)>
StartConnectedServerDummyTickerClientPair(ClientIntegrationOptions clientOptions = null,
ServerIntegrationOptions serverOptions = null)
{
var client = StartClient(clientOptions);
var server = StartServerDummyTicker(serverOptions);
await StartConnectedPairShared(client, server);
return (client, server);
}
private bool ShouldPool(IntegrationOptions options, bool server)
{
// TODO TEST POOLING client pooling
if (!server)
{
return false;
}
if (options.Pool.HasValue)
{
return options.Pool.Value;
}
if (server)
{
if (options.CVarOverrides.Count != 3)
{
return false;
}
foreach (var (cvar, value, _) in ServerTestCvars)
{
if (!options.CVarOverrides.TryGetValue(cvar, out var actualValue) ||
actualValue != value)
{
return false;
}
}
}
if (options.CVarOverrides.TryGetValue(CCVars.GameDummyTicker.Name, out var dummy) &&
dummy == "true")
{
return false;
}
if (options.CVarOverrides.TryGetValue(CCVars.GameLobbyEnabled.Name, out var lobby) &&
lobby == "true")
{
return false;
}
if (options is ClientContentIntegrationOption {ContentBeforeIoC: { }}
or ServerContentIntegrationOption {ContentBeforeIoC: { }})
{
return false;
}
return options.InitIoC == null &&
options.BeforeStart == null &&
options.ContentAssemblies == null;
}
protected override async Task OnClientReturn(ClientIntegrationInstance client)
{
await base.OnClientReturn(client);
await client.WaitIdleAsync();
var net = client.ResolveDependency<IClientNetManager>();
var prototypes = client.ResolveDependency<IPrototypeManager>();
await client.WaitPost(() =>
{
net.ClientDisconnect("Test pooling disconnect");
if (client.PreviousOptions?.ExtraPrototypes is { } oldExtra)
{
prototypes.RemoveString(oldExtra);
}
if (client.Options?.ExtraPrototypes is { } extra)
{
prototypes.LoadString(extra, true);
prototypes.ResolveResults();
}
});
await WaitUntil(client, () => !net.IsConnected);
}
protected override async Task OnServerReturn(ServerIntegrationInstance server)
{
await base.OnServerReturn(server);
await server.WaitIdleAsync();
if (server.Options != null)
{
SetServerTestCvars(server.Options);
}
var systems = server.ResolveDependency<IEntitySystemManager>();
var prototypes = server.ResolveDependency<IPrototypeManager>();
var net = server.ResolveDependency<IServerNetManager>();
var players = server.ResolveDependency<IPlayerManager>();
var gameTicker = systems.GetEntitySystem<GameTicker>();
await server.WaitPost(() =>
{
foreach (var channel in net.Channels)
{
net.DisconnectChannel(channel, "Test pooling disconnect");
}
});
await WaitUntil(server, () => players.PlayerCount == 0);
await server.WaitPost(() =>
{
gameTicker.RestartRound();
if (server.PreviousOptions?.ExtraPrototypes is { } oldExtra)
{
prototypes.RemoveString(oldExtra);
}
if (server.Options?.ExtraPrototypes is { } extra)
{
prototypes.LoadString(extra, true);
prototypes.ResolveResults();
}
});
if (!gameTicker.DummyTicker)
{
await WaitUntil(server, () => gameTicker.RunLevel == GameRunLevel.InRound);
}
}
protected async Task WaitUntil(IntegrationInstance instance, Func<bool> func, int maxTicks = 600,
int tickStep = 1)
{
await WaitUntil(instance, async () => await Task.FromResult(func()), maxTicks, tickStep);
}
protected async Task WaitUntil(IntegrationInstance instance, Func<Task<bool>> func, int maxTicks = 600,
int tickStep = 1)
{
var ticksAwaited = 0;
bool passed;
await instance.WaitIdleAsync();
while (!(passed = await func()) && ticksAwaited < maxTicks)
{
var ticksToRun = tickStep;
if (ticksAwaited + tickStep > maxTicks)
{
ticksToRun = maxTicks - ticksAwaited;
}
await instance.WaitRunTicks(ticksToRun);
ticksAwaited += ticksToRun;
}
if (!passed)
{
Assert.Fail($"Condition did not pass after {maxTicks} ticks.\n" +
$"Tests ran ({instance.TestsRan.Count}):\n" +
$"{string.Join('\n', instance.TestsRan)}");
}
Assert.That(passed);
}
private static async Task StartConnectedPairShared(ClientIntegrationInstance client,
ServerIntegrationInstance server)
{
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
client.SetConnectTarget(server);
client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null!, 0, null!));
await RunTicksSync(client, server, 10);
}
/// <summary>
/// Runs <paramref name="ticks"/> ticks on both server and client while keeping their main loop in sync.
/// </summary>
protected static async Task RunTicksSync(ClientIntegrationInstance client, ServerIntegrationInstance server,
int ticks)
{
for (var i = 0; i < ticks; i++)
{
await server.WaitRunTicks(1);
await client.WaitRunTicks(1);
}
}
protected MapId GetMainMapId(IMapManager manager)
{
// TODO a heuristic that is not this bad
return manager.GetAllMapIds().Last();
}
protected IMapGrid GetMainGrid(IMapManager manager)
{
// TODO a heuristic that is not this bad
return manager.GetAllGrids().First();
}
protected TileRef GetMainTile(IMapGrid grid)
{
// TODO a heuristic that is not this bad
return grid.GetAllTiles().First();
}
protected EntityCoordinates GetMainEntityCoordinates(IMapManager manager)
{
var gridId = GetMainGrid(manager).GridEntityId;
return new EntityCoordinates(gridId, -0.5f, -0.5f);
}
protected sealed class ClientContentIntegrationOption : ClientIntegrationOptions
{
public ClientContentIntegrationOption()
{
FailureLogLevel = LogLevel.Warning;
}
public override GameControllerOptions Options { get; set; } = new()
{
LoadContentResources = true,
LoadConfigAndUserData = false,
};
public Action ContentBeforeIoC { get; set; }
}
protected sealed class ServerContentIntegrationOption : ServerIntegrationOptions
{
public ServerContentIntegrationOption()
{
FailureLogLevel = LogLevel.Warning;
}
public override ServerOptions Options { get; set; } = new()
{
LoadContentResources = true,
LoadConfigAndUserData = false,
};
public Action ContentBeforeIoC { get; set; }
}
}
}

15
Content.IntegrationTests/ContentIntegrationTestSetup.cs
View File

@@ -1,15 +0,0 @@
using NUnit.Framework;
[SetUpFixture]
// ReSharper disable once CheckNamespace
public sealed class ContentIntegrationTestSetup
{
[OneTimeTearDown]
public void TearDown()
{
var robustSetup = new RobustIntegrationTestSetup();
robustSetup.Shutdown();
robustSetup.PrintTestPoolingInfo();
}
}

707
Content.IntegrationTests/PoolManager.cs Normal file
View File

@@ -0,0 +1,707 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Content.Client.IoC;
using Content.Client.Parallax.Managers;
using Content.IntegrationTests.Tests;
using Content.IntegrationTests.Tests.DeviceNetwork;
using Content.IntegrationTests.Tests.Interaction.Click;
using Content.IntegrationTests.Tests.Networking;
using Content.Server.GameTicking;
using Content.Shared.CCVar;
using Content.Shared.Maps;
using NUnit.Framework;
using Robust.Client;
using Robust.Server;
using Robust.Shared.Configuration;
using Robust.Shared.ContentPack;
using Robust.Shared.Exceptions;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Log;
using Robust.Shared.Map;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;
using Robust.Shared.Timing;
using Robust.UnitTesting;
[assembly: LevelOfParallelism(3)]
namespace Content.IntegrationTests;
public static class PoolManager
{
private static readonly (string cvar, string value, bool tryAdd)[] ServerTestCvars =
{
(CCVars.DatabaseSynchronous.Name, "true", false),
(CCVars.DatabaseSqliteDelay.Name, "0", false),
(CCVars.HolidaysEnabled.Name, "false", false),
(CCVars.GameMap.Name, "empty", true),
(CCVars.GameMapForced.Name, "true", true),
(CCVars.AdminLogsQueueSendDelay.Name, "0", true),
(CCVars.NetPVS.Name, "false", true),
(CCVars.NetInterp.Name, "false", true),
(CCVars.NPCMaxUpdates.Name, "999999", true),
(CCVars.GameMapForced.Name, "true", true),
(CCVars.SysWinTickPeriod.Name, "0", true),
(CCVars.ContactMinimumThreads.Name, "1", true),
(CCVars.ContactMultithreadThreshold.Name, "999", true),
(CCVars.PositionConstraintsMinimumThread.Name, "1", true),
(CCVars.PositionConstraintsPerThread.Name, "999", true),
(CCVars.VelocityConstraintMinimumThreads.Name, "1", true),
(CCVars.VelocityConstraintsPerThread.Name, "999", true),
(CCVars.ThreadParallelCount.Name, "1", true),
};
private static int PairId = 0;
private static object PairLock = new object();
private static List<Pair> Pairs = new();
private static async Task ConfigurePrototypes(RobustIntegrationTest.IntegrationInstance instance,
PoolSettings settings)
{
await instance.WaitPost(() =>
{
var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
var changes = new Dictionary<Type, HashSet<string>>();
prototypeManager.LoadString(settings.ExtraPrototypes.Trim(), true, changes);
prototypeManager.ReloadPrototypes(changes);
});
}
private static async Task<RobustIntegrationTest.ServerIntegrationInstance> GenerateServer(PoolSettings poolSettings)
{
var options = new RobustIntegrationTest.ServerIntegrationOptions
{
ExtraPrototypes = poolSettings.ExtraPrototypes,
ContentStart = true,
Options = new ServerOptions()
{
LoadConfigAndUserData = false,
LoadContentResources = !poolSettings.NoLoadContent,
},
ContentAssemblies = new[]
{
typeof(Shared.Entry.EntryPoint).Assembly,
typeof(Server.Entry.EntryPoint).Assembly,
typeof(PoolManager).Assembly
}
};
options.BeforeStart += () =>
{
IoCManager.Resolve<IEntitySystemManager>()
.LoadExtraSystemType<SimplePredictReconcileTest.PredictionTestEntitySystem>();
IoCManager.Resolve<IComponentFactory>().RegisterClass<SimplePredictReconcileTest.PredictionTestComponent>();
IoCManager.Register<ResettingEntitySystemTests.TestRoundRestartCleanupEvent>();
IoCManager.Register<InteractionSystemTests.TestInteractionSystem>();
IoCManager.Register<DeviceNetworkTestSystem>();
IoCManager.Resolve<IEntitySystemManager>()
.LoadExtraSystemType<ResettingEntitySystemTests.TestRoundRestartCleanupEvent>();
IoCManager.Resolve<IEntitySystemManager>()
.LoadExtraSystemType<InteractionSystemTests.TestInteractionSystem>();
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<DeviceNetworkTestSystem>();
IoCManager.Resolve<ILogManager>().GetSawmill("loc").Level = LogLevel.Error;
};
SetupCVars(poolSettings, options);
var server = new RobustIntegrationTest.ServerIntegrationInstance(options);
await server.WaitIdleAsync();
return server;
}
public static void Shutdown()
{
lock (PairLock)
{
var pairs = Pairs;
// We are trying to make things blow up if they are still happening after this method.
Pairs = null;
foreach (var pair in pairs)
{
pair.Client.Dispose();
pair.Server.Dispose();
}
}
}
private static async Task<RobustIntegrationTest.ClientIntegrationInstance> GenerateClient(PoolSettings poolSettings)
{
var options = new RobustIntegrationTest.ClientIntegrationOptions
{
FailureLogLevel = LogLevel.Warning,
ContentStart = true,
ExtraPrototypes = poolSettings.ExtraPrototypes,
ContentAssemblies = new[]
{
typeof(Shared.Entry.EntryPoint).Assembly,
typeof(Client.Entry.EntryPoint).Assembly,
typeof(PoolManager).Assembly
}
};
if (poolSettings.NoLoadContent)
{
Assert.Warn("NoLoadContent does not work on the client, ignoring");
}
options.Options = new GameControllerOptions()
{
LoadConfigAndUserData = false,
// LoadContentResources = !poolSettings.NoLoadContent
};
options.BeforeStart += () =>
{
IoCManager.Resolve<IModLoader>().SetModuleBaseCallbacks(new ClientModuleTestingCallbacks
{
ClientBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>()
.LoadExtraSystemType<SimplePredictReconcileTest.PredictionTestEntitySystem>();
IoCManager.Resolve<IComponentFactory>()
.RegisterClass<SimplePredictReconcileTest.PredictionTestComponent>();
IoCManager.Register<IParallaxManager, DummyParallaxManager>(true);
IoCManager.Resolve<ILogManager>().GetSawmill("loc").Level = LogLevel.Error;
}
});
};
SetupCVars(poolSettings, options);
var client = new RobustIntegrationTest.ClientIntegrationInstance(options);
await client.WaitIdleAsync();
return client;
}
private static void SetupCVars(PoolSettings poolSettings, RobustIntegrationTest.IntegrationOptions options)
{
foreach (var serverTestCvar in ServerTestCvars)
{
options.CVarOverrides[serverTestCvar.cvar] = serverTestCvar.value;
}
if (poolSettings.DummyTicker)
{
options.CVarOverrides[CCVars.GameDummyTicker.Name] = "true";
}
if (poolSettings.InLobby)
{
options.CVarOverrides[CCVars.GameLobbyEnabled.Name] = "true";
}
if (poolSettings.DisableInterpolate)
{
options.CVarOverrides[CCVars.NetInterp.Name] = "false";
}
if (poolSettings.Map != null)
{
options.CVarOverrides[CCVars.GameMap.Name] = poolSettings.Map;
}
}
public static async Task<PairTracker> GetServerClient(PoolSettings poolSettings = null,
[System.Runtime.CompilerServices.CallerFilePath] string testMethodFilePath = "",
[System.Runtime.CompilerServices.CallerMemberName] string testMethodName = "") =>
await GetServerClientPair(poolSettings ?? new PoolSettings(), $"{testMethodFilePath}, {testMethodName}");
private static async Task<PairTracker> GetServerClientPair(PoolSettings poolSettings, string testMethodName)
{
var poolRetrieveTimeWatch = new Stopwatch();
poolRetrieveTimeWatch.Start();
await TestContext.Out.WriteLineAsync("Getting server/client");
Pair pair;
if (poolSettings.MustBeNew)
{
await TestContext.Out.WriteLineAsync($"Creating, because must be new pair");
pair = await CreateServerClientPair(poolSettings);
}
else
{
pair = GrabOptimalPair(poolSettings);
if (pair != null)
{
var mapManager = pair.Server.ResolveDependency<IMapManager>();
var mainGrid = GetMainGrid(mapManager);
var canSkip = pair.Settings.CanFastRecycle(poolSettings);
await TestContext.Out.WriteLineAsync($"canSkip: {canSkip}, maingrid:{mainGrid != null}");
if (!canSkip || mainGrid == null)
{
await TestContext.Out.WriteLineAsync($"Cleaning existing pair");
await CleanPooledPair(poolSettings, pair);
}
else
{
await TestContext.Out.WriteLineAsync($"Skip cleanup pair");
}
}
else
{
await TestContext.Out.WriteLineAsync($"Creating, because pool empty");
pair = await CreateServerClientPair(poolSettings);
}
}
var poolRetrieveTime = poolRetrieveTimeWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Got server/client (id:{pair.PairId},uses:{pair.TestHistory.Count}) in {poolRetrieveTime.TotalMilliseconds} ms");
pair.Settings = poolSettings;
TestContext.Out.WriteLine($"Test History|\n{string.Join('\n', pair.TestHistory)}\n|Test History End");
pair.TestHistory.Add(testMethodName);
var usageWatch = new Stopwatch();
usageWatch.Start();
return new PairTracker()
{
Pair = pair,
UsageWatch = usageWatch
};
}
private static Pair GrabOptimalPair(PoolSettings poolSettings)
{
lock (PairLock)
{
if (Pairs.Count == 0) return null;
for (var i = 0; i < Pairs.Count; i++)
{
var pair = Pairs[i];
if (!pair.Settings.CanFastRecycle(poolSettings)) continue;
Pairs.RemoveAt(i);
return pair;
}
var defaultPair = Pairs[^1];
Pairs.RemoveAt(Pairs.Count - 1);
return defaultPair;
}
}
/// <summary>
/// Used after checking pairs, Don't use this directly
/// </summary>
/// <param name="pair"></param>
public static void NoCheckReturn(Pair pair)
{
lock (PairLock)
{
Pairs.Add(pair);
}
}
private static async Task CleanPooledPair(PoolSettings poolSettings, Pair pair)
{
var methodWatch = new Stopwatch();
methodWatch.Start();
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Setting CVar ");
var configManager = pair.Server.ResolveDependency<IConfigurationManager>();
await pair.Server.WaitPost(() =>
{
configManager.SetCVar(CCVars.GameLobbyEnabled, poolSettings.InLobby);
});
var cNetMgr = pair.Client.ResolveDependency<IClientNetManager>();
if (!cNetMgr.IsConnected)
{
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Connecting client, and restarting server");
pair.Client.SetConnectTarget(pair.Server);
await pair.Server.WaitPost(() =>
{
EntitySystem.Get<GameTicker>().RestartRound();
});
await pair.Client.WaitPost(() =>
{
cNetMgr.ClientConnect(null!, 0, null!);
});
await ReallyBeIdle(pair,11);
}
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Disconnecting client, and restarting server");
await pair.Client.WaitPost(() =>
{
cNetMgr.ClientDisconnect("Test pooling cleanup disconnect");
});
await ReallyBeIdle(pair, 5);
if (!string.IsNullOrWhiteSpace(pair.Settings.ExtraPrototypes))
{
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Removing prototypes");
if (!pair.Settings.NoServer)
{
var serverProtoManager = pair.Server.ResolveDependency<IPrototypeManager>();
await pair.Server.WaitPost(() =>
{
serverProtoManager.RemoveString(pair.Settings.ExtraPrototypes.Trim());
});
}
if(!pair.Settings.NoClient)
{
var clientProtoManager = pair.Client.ResolveDependency<IPrototypeManager>();
await pair.Client.WaitPost(() =>
{
clientProtoManager.RemoveString(pair.Settings.ExtraPrototypes.Trim());
});
}
await ReallyBeIdle(pair, 1);
}
if (poolSettings.ExtraPrototypes != null)
{
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Adding prototypes");
if (!poolSettings.NoServer)
{
await ConfigurePrototypes(pair.Server, poolSettings);
}
if (!poolSettings.NoClient)
{
await ConfigurePrototypes(pair.Client, poolSettings);
}
}
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Restarting server again");
await pair.Server.WaitPost(() =>
{
EntitySystem.Get<GameTicker>().RestartRound();
});
if (!poolSettings.NotConnected)
{
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Connecting client");
await ReallyBeIdle(pair);
pair.Client.SetConnectTarget(pair.Server);
await pair.Client.WaitPost(() =>
{
var netMgr = IoCManager.Resolve<IClientNetManager>();
if (!netMgr.IsConnected)
{
netMgr.ClientConnect(null!, 0, null!);
}
});
}
await ReallyBeIdle(pair);
await TestContext.Out.WriteLineAsync($"Recycling: {methodWatch.Elapsed.TotalMilliseconds} ms: Done recycling");
}
private static async Task<Pair> CreateServerClientPair(PoolSettings poolSettings)
{
var client = await GenerateClient(poolSettings);
var server = await GenerateServer(poolSettings);
var pair = new Pair { Server = server, Client = client, PairId = Interlocked.Increment(ref PairId)};
if (!poolSettings.NotConnected)
{
pair.Client.SetConnectTarget(pair.Server);
await pair.Client.WaitPost(() =>
{
var netMgr = IoCManager.Resolve<IClientNetManager>();
if (!netMgr.IsConnected)
{
netMgr.ClientConnect(null!, 0, null!);
}
});
await ReallyBeIdle(pair, 10);
await client.WaitRunTicks(1);
}
return pair;
}
public static TileRef GetMainTile(IMapManager manager)
{
foreach (var grid in manager.GetAllGrids())
{
if (manager.GridExists(grid.GridEntityId))
{
foreach (var tile in grid.GetAllTiles())
{
if(tile.IsSpace())continue;
if(tile.IsBlockedTurf(false))continue;
return tile;
}
}
}
throw new Exception("Failed to find empty tile");
}
public static EntityCoordinates GetMainEntityCoordinates(IMapManager manager)
{
var gridId = GetMainGrid(manager).GridEntityId;
return new EntityCoordinates(gridId, -0.5f, -0.5f);
}
public static IMapGrid GetMainGrid(IMapManager manager)
{
foreach (var grid in manager.GetAllGrids())
{
if (manager.GridExists(grid.GridEntityId))
return grid;
}
return null;
}
public static async Task RunTicksSync(Pair pair, int ticks)
{
for (var i = 0; i < ticks; i++)
{
await pair.Server.WaitRunTicks(1);
await pair.Client.WaitRunTicks(1);
}
}
public static async Task WaitUntil(RobustIntegrationTest.IntegrationInstance instance, Func<bool> func,
int maxTicks = 600,
int tickStep = 1)
{
await WaitUntil(instance, async () => await Task.FromResult(func()), maxTicks, tickStep);
}
public static async Task ReallyBeIdle(Pair pair, int runTicks = 25)
{
for (int i = 0; i < runTicks; i++)
{
await pair.Client.WaitRunTicks(1);
await pair.Server.WaitRunTicks(1);
for (int idleCycles = 0; idleCycles < 4; idleCycles++)
{
await pair.Client.WaitIdleAsync();
await pair.Server.WaitIdleAsync();
}
}
}
public static async Task WaitUntil(RobustIntegrationTest.IntegrationInstance instance, Func<Task<bool>> func,
int maxTicks = 600,
int tickStep = 1)
{
var ticksAwaited = 0;
bool passed;
await instance.WaitIdleAsync();
while (!(passed = await func()) && ticksAwaited < maxTicks)
{
var ticksToRun = tickStep;
if (ticksAwaited + tickStep > maxTicks)
{
ticksToRun = maxTicks - ticksAwaited;
}
await instance.WaitRunTicks(ticksToRun);
ticksAwaited += ticksToRun;
}
if (!passed)
{
Assert.Fail($"Condition did not pass after {maxTicks} ticks.\n" +
$"Tests ran ({instance.TestsRan.Count}):\n" +
$"{string.Join('\n', instance.TestsRan)}");
}
Assert.That(passed);
}
}
public sealed class PoolSettings
{
// Todo: We can make more of these pool-able, if we need enough of them for it to matter
public bool MustNotBeReused => Destructive || NoLoadContent || DisableInterpolate || DummyTicker;
public bool MustBeNew => Fresh || NoLoadContent || DisableInterpolate || DummyTicker;
public bool NotConnected => NoClient || NoServer || Disconnected;
/// <summary>
/// We are going to ruin this pair
/// </summary>
public bool Destructive { get; init; }
/// <summary>
/// We need a brand new pair
/// </summary>
public bool Fresh { get; init; }
/// <summary>
/// We need a pair that uses a dummy ticker
/// </summary>
public bool DummyTicker { get; init; }
/// <summary>
/// We need the client, and server to be disconnected
/// </summary>
public bool Disconnected { get; init; }
/// <summary>
/// We need the server to be in the lobby
/// </summary>
public bool InLobby { get; init; }
/// <summary>
/// We don't want content loaded
/// </summary>
public bool NoLoadContent { get; init; }
/// <summary>
/// We want to add some prototypes
/// </summary>
public string ExtraPrototypes { get; init; }
/// <summary>
/// Disables NetInterp
/// </summary>
public bool DisableInterpolate { get; init; }
/// <summary>
/// Tells the pool it has to clean up before the server/client can be used.
/// </summary>
public bool Dirty { get; init; }
/// <summary>
/// Sets the map Cvar, and loads the map
/// </summary>
public string Map { get; init; } // TODO for map painter
/// <summary>
/// The test won't use the client (so we can skip cleaning it)
/// </summary>
public bool NoClient { get; init; }
/// <summary>
/// The test won't use the client (so we can skip cleaning it)
/// </summary>
public bool NoServer { get; init; }
/// <summary>
/// Guess if skipping recycling is ok
/// </summary>
/// <param name="nextSettings">The next set of settings the old pair will be set to</param>
/// <returns></returns>
public bool CanFastRecycle(PoolSettings nextSettings)
{
if (Dirty) return false;
if (Destructive || nextSettings.Destructive) return false;
if (NotConnected != nextSettings.NotConnected) return false;
if (InLobby != nextSettings.InLobby) return false;
if (DisableInterpolate != nextSettings.DisableInterpolate) return false;
if (nextSettings.DummyTicker) return false;
if (Map != nextSettings.Map) return false;
if (NoLoadContent != nextSettings.NoLoadContent) return false;
if (nextSettings.Fresh) return false;
if (ExtraPrototypes != nextSettings.ExtraPrototypes) return false;
return true;
}
}
public sealed class Pair
{
public int PairId { get; init; }
public List<string> TestHistory { get; set; } = new();
public PoolSettings Settings { get; set; }
public RobustIntegrationTest.ServerIntegrationInstance Server { get; init; }
public RobustIntegrationTest.ClientIntegrationInstance Client { get; init; }
}
public sealed class PairTracker : IAsyncDisposable
{
private int _disposed;
public async Task OnDirtyDispose()
{
var usageTime = UsageWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Dirty: Test returned in {usageTime.TotalMilliseconds} ms");
var dirtyWatch = new Stopwatch();
dirtyWatch.Start();
Pair.Client.Dispose();
Pair.Server.Dispose();
var disposeTime = dirtyWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Dirty: Disposed in {disposeTime.TotalMilliseconds} ms");
}
public async Task OnCleanDispose()
{
var usageTime = UsageWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Clean: Test returned in {usageTime.TotalMilliseconds} ms");
var cleanWatch = new Stopwatch();
cleanWatch.Start();
// Let any last minute failures the test cause happen.
await PoolManager.ReallyBeIdle(Pair);
if (!Pair.Settings.Destructive)
{
if (Pair.Client.IsAlive == false)
{
throw new Exception("Test killed the client", Pair.Client.UnhandledException);
}
if (Pair.Server.IsAlive == false)
{
throw new Exception("Test killed the server", Pair.Server.UnhandledException);
}
}
if (Pair.Settings.MustNotBeReused)
{
Pair.Client.Dispose();
Pair.Server.Dispose();
var returnTime2 = cleanWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Clean: Clean disposed in {returnTime2.TotalMilliseconds} ms");
return;
}
var sRuntimeLog = Pair.Server.ResolveDependency<IRuntimeLog>();
if (sRuntimeLog.ExceptionCount > 0) throw new Exception("Server logged exceptions");
var cRuntimeLog = Pair.Client.ResolveDependency<IRuntimeLog>();
if (cRuntimeLog.ExceptionCount > 0) throw new Exception("Client logged exceptions");
PoolManager.NoCheckReturn(Pair);
var returnTime = cleanWatch.Elapsed;
await TestContext.Out.WriteLineAsync($"Clean: Clean returned to pool in {returnTime.TotalMilliseconds} ms");
}
public Stopwatch UsageWatch { get; set; }
public Pair Pair { get; init; }
public async ValueTask CleanReturnAsync()
{
var disposed = Interlocked.Exchange(ref _disposed, 1);
switch (disposed)
{
case 0:
await TestContext.Out.WriteLineAsync("Clean Return Start");
break;
case 1:
throw new Exception("Already called clean return before");
case 2:
throw new Exception("Already dirty disposed");
default:
throw new Exception("Unexpected disposed value");
}
await OnCleanDispose();
await TestContext.Out.WriteLineAsync($"Clean Return Exiting");
}
public async ValueTask DisposeAsync()
{
var disposed = Interlocked.Exchange(ref _disposed, 2);
switch (disposed)
{
case 0:
await TestContext.Out.WriteLineAsync("Dirty Return Start");
break;
case 1:
await TestContext.Out.WriteLineAsync("Dirty Return - Already Clean Disposed");
return;
case 2:
throw new Exception("Already called dirty return before");
default:
throw new Exception("Unexpected disposed value");
}
await OnDirtyDispose();
await TestContext.Out.WriteLineAsync($"Dirty Return Exiting");
}
}

15
Content.IntegrationTests/PoolManagerTestEventHandler.cs Normal file
View File

@@ -0,0 +1,15 @@
using NUnit.Framework;
[assembly: Parallelizable(ParallelScope.Children)]
namespace Content.IntegrationTests;
[SetUpFixture]
public sealed class PoolManagerTestEventHandler
{
[OneTimeTearDown]
public void TearDown()
{
PoolManager.Shutdown();
}
}

7
Content.IntegrationTests/Tests/AI/BehaviorSetsTest.cs
View File

@@ -12,13 +12,13 @@ namespace Content.IntegrationTests.Tests.AI
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(BehaviorSetPrototype))] [TestOf(typeof(BehaviorSetPrototype))]
public sealed class BehaviorSetsTest : ContentIntegrationTest public sealed class BehaviorSetsTest
{ {
[Test] [Test]
public async Task TestBehaviorSets() public async Task TestBehaviorSets()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
await server.WaitIdleAsync(); var server = pairTracker.Pair.Server;
var protoManager = server.ResolveDependency<IPrototypeManager>(); var protoManager = server.ResolveDependency<IPrototypeManager>();
var reflectionManager = server.ResolveDependency<IReflectionManager>(); var reflectionManager = server.ResolveDependency<IReflectionManager>();
@@ -56,6 +56,7 @@ namespace Content.IntegrationTests.Tests.AI
} }
} }
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

7
Content.IntegrationTests/Tests/Access/AccessReaderTest.cs
View File

@@ -9,12 +9,14 @@ namespace Content.IntegrationTests.Tests.Access
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(AccessReaderComponent))] [TestOf(typeof(AccessReaderComponent))]
public sealed class AccessReaderTest : ContentIntegrationTest public sealed class AccessReaderTest
{ {
[Test] [Test]
public async Task TestTags() public async Task TestTags()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var system = EntitySystem.Get<AccessReaderSystem>(); var system = EntitySystem.Get<AccessReaderSystem>();
@@ -69,6 +71,7 @@ namespace Content.IntegrationTests.Tests.Access
Assert.That(system.IsAllowed(new[] { "A", "B" }, reader), Is.False); Assert.That(system.IsAllowed(new[] { "A", "B" }, reader), Is.False);
Assert.That(system.IsAllowed(new string[] { }, reader), Is.False); Assert.That(system.IsAllowed(new string[] { }, reader), Is.False);
}); });
await pairTracker.CleanReturnAsync();
} }
} }

119
Content.IntegrationTests/Tests/Administration/Logs/AddTests.cs
View File

@@ -5,11 +5,13 @@ using System.Threading.Tasks;
using Content.Server.Administration.Logs; using Content.Server.Administration.Logs;
using Content.Server.Database; using Content.Server.Database;
using Content.Server.GameTicking; using Content.Server.GameTicking;
using Content.Server.GameTicking.Commands;
using Content.Shared.Administration.Logs; using Content.Shared.Administration.Logs;
using Content.Shared.CCVar; using Content.Shared.CCVar;
using Content.Shared.Database; using Content.Shared.Database;
using NUnit.Framework; using NUnit.Framework;
using Robust.Server.Player; using Robust.Server.Player;
using Robust.Shared.Configuration;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.Map; using Robust.Shared.Map;
@@ -17,24 +19,16 @@ namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture] [TestFixture]
[TestOf(typeof(AdminLogSystem))] [TestOf(typeof(AdminLogSystem))]
public sealed class AddTests : ContentIntegrationTest public sealed class AddTests
{ {
[Test] [Test]
public async Task AddAndGetSingleLog() public async Task AddAndGetSingleLog()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>(); var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>(); var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
@@ -42,13 +36,13 @@ public sealed class AddTests : ContentIntegrationTest
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var coordinates = GetMainEntityCoordinates(sMaps); var coordinates = PoolManager.GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates); var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {guid}"); sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {guid}");
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = sAdminLogSystem.CurrentRoundJson(new LogFilter var logs = sAdminLogSystem.CurrentRoundJson(new LogFilter
{ {
@@ -69,20 +63,15 @@ public sealed class AddTests : ContentIntegrationTest
return false; return false;
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task AddAndGetUnformattedLog() public async Task AddAndGetUnformattedLog()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sDatabase = server.ResolveDependency<IServerDbManager>(); var sDatabase = server.ResolveDependency<IServerDbManager>();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
@@ -96,7 +85,7 @@ public sealed class AddTests : ContentIntegrationTest
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var coordinates = GetMainEntityCoordinates(sMaps); var coordinates = PoolManager.GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates); var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity} test log: {guid}"); sAdminLogSystem.Add(LogType.Unknown, $"{entity} test log: {guid}");
@@ -104,7 +93,7 @@ public sealed class AddTests : ContentIntegrationTest
SharedAdminLog log = default; SharedAdminLog log = default;
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter
{ {
@@ -136,31 +125,25 @@ public sealed class AddTests : ContentIntegrationTest
json.Dispose(); json.Dispose();
} }
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
[TestCase(500)] [TestCase(500)]
public async Task BulkAddLogs(int amount) public async Task BulkAddLogs(int amount)
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>(); var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>(); var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var coordinates = GetMainEntityCoordinates(sMaps); var coordinates = PoolManager.GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates); var entity = sEntities.SpawnEntity(null, coordinates);
for (var i = 0; i < amount; i++) for (var i = 0; i < amount; i++)
@@ -169,26 +152,20 @@ public sealed class AddTests : ContentIntegrationTest
} }
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var messages = await sAdminLogSystem.CurrentRoundLogs(); var messages = await sAdminLogSystem.CurrentRoundLogs();
return messages.Count >= amount; return messages.Count >= amount;
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task AddPlayerSessionLog() public async Task AddPlayerSessionLog()
{ {
var (client, server) = await StartConnectedServerClientPair(serverOptions: new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient();
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sPlayers = server.ResolveDependency<IPlayerManager>(); var sPlayers = server.ResolveDependency<IPlayerManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>(); var sSystems = server.ResolveDependency<IEntitySystemManager>();
@@ -207,7 +184,7 @@ public sealed class AddTests : ContentIntegrationTest
}); });
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = await sAdminLogSystem.CurrentRoundLogs(); var logs = await sAdminLogSystem.CurrentRoundLogs();
if (logs.Count == 0) if (logs.Count == 0)
@@ -218,20 +195,22 @@ public sealed class AddTests : ContentIntegrationTest
Assert.That(logs.First().Players, Does.Contain(playerGuid)); Assert.That(logs.First().Players, Does.Contain(playerGuid));
return true; return true;
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task PreRoundAddAndGetSingle() public async Task PreRoundAddAndGetSingle()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{Dirty = true});
var server = pairTracker.Pair.Server;
var configManager = server.ResolveDependency<IConfigurationManager>();
await server.WaitPost(() =>
{ {
CVarOverrides = configManager.SetCVar(CCVars.GameLobbyEnabled, true);
{ var command = new RestartRoundNowCommand();
[CCVars.AdminLogsQueueSendDelay.Name] = "0", command.Execute(null, string.Empty, Array.Empty<string>());
[CCVars.GameLobbyEnabled.Name] = "true"
},
}); });
await server.WaitIdleAsync();
var sDatabase = server.ResolveDependency<IServerDbManager>(); var sDatabase = server.ResolveDependency<IServerDbManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>(); var sSystems = server.ResolveDependency<IEntitySystemManager>();
@@ -253,7 +232,7 @@ public sealed class AddTests : ContentIntegrationTest
SharedAdminLog log = default; SharedAdminLog log = default;
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter
{ {
@@ -284,20 +263,14 @@ public sealed class AddTests : ContentIntegrationTest
json.Dispose(); json.Dispose();
} }
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task DuplicatePlayerDoesNotThrowTest() public async Task DuplicatePlayerDoesNotThrowTest()
{ {
var (client, server) = await StartConnectedServerClientPair(serverOptions: new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient();
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
});
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sPlayers = server.ResolveDependency<IPlayerManager>(); var sPlayers = server.ResolveDependency<IPlayerManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>(); var sSystems = server.ResolveDependency<IEntitySystemManager>();
@@ -313,7 +286,7 @@ public sealed class AddTests : ContentIntegrationTest
sAdminLogSystem.Add(LogType.Unknown, $"{player} {player} test log: {guid}"); sAdminLogSystem.Add(LogType.Unknown, $"{player} {player} test log: {guid}");
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter
{ {
@@ -328,24 +301,17 @@ public sealed class AddTests : ContentIntegrationTest
return true; return true;
}); });
await pairTracker.CleanReturnAsync();
Assert.Pass(); Assert.Pass();
} }
[Test] [Test]
public async Task DuplicatePlayerIdDoesNotThrowTest() public async Task DuplicatePlayerIdDoesNotThrowTest()
{ {
var (client, server) = await StartConnectedServerClientPair(serverOptions: new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient();
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
});
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sPlayers = server.ResolveDependency<IPlayerManager>(); var sPlayers = server.ResolveDependency<IPlayerManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>(); var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
@@ -358,7 +324,7 @@ public sealed class AddTests : ContentIntegrationTest
sAdminLogSystem.Add(LogType.Unknown, $"{player:first} {player:second} test log: {guid}"); sAdminLogSystem.Add(LogType.Unknown, $"{player:first} {player:second} test log: {guid}");
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter var logs = await sAdminLogSystem.CurrentRoundLogs(new LogFilter
{ {
@@ -373,6 +339,7 @@ public sealed class AddTests : ContentIntegrationTest
return true; return true;
}); });
await pairTracker.CleanReturnAsync();
Assert.Pass(); Assert.Pass();
} }
} }

21
Content.IntegrationTests/Tests/Administration/Logs/FilterTests.cs
View File

@@ -12,26 +12,18 @@ namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture] [TestFixture]
[TestOf(typeof(AdminLogSystem))] [TestOf(typeof(AdminLogSystem))]
public sealed class FilterTests : ContentIntegrationTest public sealed class FilterTests
{ {
[Test] [Test]
[TestCase(DateOrder.Ascending)] [TestCase(DateOrder.Ascending)]
[TestCase(DateOrder.Descending)] [TestCase(DateOrder.Descending)]
public async Task Date(DateOrder order) public async Task Date(DateOrder order)
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
},
Pool = true
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var sMaps = server.ResolveDependency<IMapManager>(); var sMaps = server.ResolveDependency<IMapManager>();
var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>(); var sAdminLogSystem = server.ResolveDependency<IAdminLogManager>();
@@ -41,7 +33,7 @@ public sealed class FilterTests : ContentIntegrationTest
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var coordinates = GetMainEntityCoordinates(sMaps); var coordinates = PoolManager.GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates); var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {commonGuid} {firstGuid}"); sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {commonGuid} {firstGuid}");
@@ -51,13 +43,13 @@ public sealed class FilterTests : ContentIntegrationTest
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var coordinates = GetMainEntityCoordinates(sMaps); var coordinates = PoolManager.GetMainEntityCoordinates(sMaps);
var entity = sEntities.SpawnEntity(null, coordinates); var entity = sEntities.SpawnEntity(null, coordinates);
sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {commonGuid} {secondGuid}"); sAdminLogSystem.Add(LogType.Unknown, $"{entity:Entity} test log: {commonGuid} {secondGuid}");
}); });
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
var commonGuidStr = commonGuid.ToString(); var commonGuidStr = commonGuid.ToString();
@@ -110,5 +102,6 @@ public sealed class FilterTests : ContentIntegrationTest
return firstFound && secondFound; return firstFound && secondFound;
}); });
await pairTracker.CleanReturnAsync();
} }
} }

18
Content.IntegrationTests/Tests/Administration/Logs/QueryTests.cs
View File

@@ -14,21 +14,13 @@ namespace Content.IntegrationTests.Tests.Administration.Logs;
[TestFixture] [TestFixture]
[TestOf(typeof(AdminLogSystem))] [TestOf(typeof(AdminLogSystem))]
public sealed class QueryTests : ContentIntegrationTest public sealed class QueryTests
{ {
[Test] [Test]
public async Task QuerySingleLog() public async Task QuerySingleLog()
{ {
var serverOptions = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient();
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.AdminLogsQueueSendDelay.Name] = "0"
}
};
var (client, server) = await StartConnectedServerClientPair(serverOptions: serverOptions);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sSystems = server.ResolveDependency<IEntitySystemManager>(); var sSystems = server.ResolveDependency<IEntitySystemManager>();
var sPlayers = server.ResolveDependency<IPlayerManager>(); var sPlayers = server.ResolveDependency<IPlayerManager>();
@@ -57,7 +49,7 @@ public sealed class QueryTests : ContentIntegrationTest
AnyPlayers = new[] {player.UserId.UserId} AnyPlayers = new[] {player.UserId.UserId}
}; };
await WaitUntil(server, async () => await PoolManager.WaitUntil(server, async () =>
{ {
foreach (var _ in await sAdminLogSystem.All(filter)) foreach (var _ in await sAdminLogSystem.All(filter))
{ {
@@ -66,5 +58,7 @@ public sealed class QueryTests : ContentIntegrationTest
return false; return false;
}); });
await pairTracker.CleanReturnAsync();
} }
} }

11
Content.IntegrationTests/Tests/Atmos/AlarmThresholdTest.cs
View File

@@ -7,7 +7,7 @@ namespace Content.IntegrationTests.Tests.Atmos
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(AtmosAlarmThreshold))] [TestOf(typeof(AtmosAlarmThreshold))]
public sealed class AlarmThresholdTest : ContentIntegrationTest public sealed class AlarmThresholdTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: alarmThreshold - type: alarmThreshold
@@ -21,12 +21,8 @@ namespace Content.IntegrationTests.Tests.Atmos
[Test] [Test]
public async Task TestAlarmThreshold() public async Task TestAlarmThreshold()
{ {
var server = StartServerDummyTicker(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var prototypeManager = server.ResolveDependency<IPrototypeManager>(); var prototypeManager = server.ResolveDependency<IPrototypeManager>();
AtmosAlarmThreshold threshold = default!; AtmosAlarmThreshold threshold = default!;
@@ -91,6 +87,7 @@ namespace Content.IntegrationTests.Tests.Atmos
Assert.That(threshold.UpperBound, Is.EqualTo(null)); Assert.That(threshold.UpperBound, Is.EqualTo(null));
Assert.That(threshold.LowerBound, Is.EqualTo(null)); Assert.That(threshold.LowerBound, Is.EqualTo(null));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

8
Content.IntegrationTests/Tests/Atmos/ConstantsTest.cs
View File

@@ -10,14 +10,13 @@ namespace Content.IntegrationTests.Tests.Atmos
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(Atmospherics))] [TestOf(typeof(Atmospherics))]
public sealed class ConstantsTest : ContentIntegrationTest public sealed class ConstantsTest
{ {
[Test] [Test]
public async Task TotalGasesTest() public async Task TotalGasesTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
await server.WaitPost(() => await server.WaitPost(() =>
{ {
@@ -27,6 +26,7 @@ namespace Content.IntegrationTests.Tests.Atmos
Assert.That(Enum.GetValues(typeof(Gas)).Length, Is.EqualTo(Atmospherics.TotalNumberOfGases)); Assert.That(Enum.GetValues(typeof(Gas)).Length, Is.EqualTo(Atmospherics.TotalNumberOfGases));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

18
Content.IntegrationTests/Tests/Atmos/GasMixtureTest.cs
View File

@@ -9,18 +9,17 @@ namespace Content.IntegrationTests.Tests.Atmos
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(GasMixture))] [TestOf(typeof(GasMixture))]
public sealed class GasMixtureTest : ContentIntegrationTest public sealed class GasMixtureTest
{ {
[Test] [Test]
public async Task TestMerge() public async Task TestMerge()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var atmosphereSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<AtmosphereSystem>(); var atmosphereSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<AtmosphereSystem>();
server.Assert(() => await server.WaitAssertion(() =>
{ {
var a = new GasMixture(10f); var a = new GasMixture(10f);
var b = new GasMixture(10f); var b = new GasMixture(10f);
@@ -48,7 +47,7 @@ namespace Content.IntegrationTests.Tests.Atmos
Assert.That(a.GetMoles(Gas.Oxygen), Is.EqualTo(50)); Assert.That(a.GetMoles(Gas.Oxygen), Is.EqualTo(50));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
@@ -60,9 +59,10 @@ namespace Content.IntegrationTests.Tests.Atmos
[TestCase(Atmospherics.BreathPercentage)] [TestCase(Atmospherics.BreathPercentage)]
public async Task RemoveRatio(float ratio) public async Task RemoveRatio(float ratio)
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var a = new GasMixture(10f); var a = new GasMixture(10f);
@@ -85,7 +85,7 @@ namespace Content.IntegrationTests.Tests.Atmos
Assert.That(a.GetMoles(Gas.Nitrogen), Is.EqualTo(100 - b.GetMoles(Gas.Nitrogen))); Assert.That(a.GetMoles(Gas.Nitrogen), Is.EqualTo(100 - b.GetMoles(Gas.Nitrogen)));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

7
Content.IntegrationTests/Tests/Body/LegTest.cs
View File

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests.Body
[TestFixture] [TestFixture]
[TestOf(typeof(SharedBodyComponent))] [TestOf(typeof(SharedBodyComponent))]
[TestOf(typeof(BodyComponent))] [TestOf(typeof(BodyComponent))]
public sealed class LegTest : ContentIntegrationTest public sealed class LegTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -32,8 +32,8 @@ namespace Content.IntegrationTests.Tests.Body
[Test] [Test]
public async Task RemoveLegsFallTest() public async Task RemoveLegsFallTest()
{ {
var options = new ServerContentIntegrationOption{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
AppearanceComponent appearance = null; AppearanceComponent appearance = null;
@@ -64,6 +64,7 @@ namespace Content.IntegrationTests.Tests.Body
Assert.That(appearance.TryGetData(RotationVisuals.RotationState, out RotationState state)); Assert.That(appearance.TryGetData(RotationVisuals.RotationState, out RotationState state));
Assert.That(state, Is.EqualTo(RotationState.Horizontal)); Assert.That(state, Is.EqualTo(RotationState.Horizontal));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

16
Content.IntegrationTests/Tests/Body/LungTest.cs
View File

@@ -13,7 +13,7 @@ namespace Content.IntegrationTests.Tests.Body
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(LungSystem))] [TestOf(typeof(LungSystem))]
public sealed class LungTest : ContentIntegrationTest public sealed class LungTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -49,8 +49,8 @@ namespace Content.IntegrationTests.Tests.Body
public async Task AirConsistencyTest() public async Task AirConsistencyTest()
{ {
// --- Setup // --- Setup
var options = new ServerContentIntegrationOption{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync(); await server.WaitIdleAsync();
@@ -121,16 +121,14 @@ namespace Content.IntegrationTests.Tests.Body
}); });
} }
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task NoSuffocationTest() public async Task NoSuffocationTest()
{ {
var options = new ServerContentIntegrationOption{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapLoader = server.ResolveDependency<IMapLoader>(); var mapLoader = server.ResolveDependency<IMapLoader>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -173,7 +171,7 @@ namespace Content.IntegrationTests.Tests.Body
}); });
} }
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

34
Content.IntegrationTests/Tests/Buckle/BuckleTest.cs
View File

@@ -17,7 +17,7 @@ namespace Content.IntegrationTests.Tests.Buckle
[TestFixture] [TestFixture]
[TestOf(typeof(BuckleComponent))] [TestOf(typeof(BuckleComponent))]
[TestOf(typeof(StrapComponent))] [TestOf(typeof(StrapComponent))]
public sealed class BuckleTest : ContentIntegrationTest public sealed class BuckleTest
{ {
private const string BuckleDummyId = "BuckleDummy"; private const string BuckleDummyId = "BuckleDummy";
private const string StrapDummyId = "StrapDummy"; private const string StrapDummyId = "StrapDummy";
@@ -51,9 +51,8 @@ namespace Content.IntegrationTests.Tests.Buckle
[Test] [Test]
public async Task BuckleUnbuckleCooldownRangeTest() public async Task BuckleUnbuckleCooldownRangeTest()
{ {
var cOptions = new ClientIntegrationOptions {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{ExtraPrototypes = Prototypes});
var sOptions = new ServerIntegrationOptions {ExtraPrototypes = Prototypes}; var server = pairTracker.Pair.Server;
var (_, server) = await StartConnectedServerClientPair(cOptions, sOptions);
EntityUid human = default; EntityUid human = default;
EntityUid chair = default; EntityUid chair = default;
@@ -68,8 +67,7 @@ namespace Content.IntegrationTests.Tests.Buckle
var actionBlocker = EntitySystem.Get<ActionBlockerSystem>(); var actionBlocker = EntitySystem.Get<ActionBlockerSystem>();
var standingState = EntitySystem.Get<StandingStateSystem>(); var standingState = EntitySystem.Get<StandingStateSystem>();
var grid = GetMainGrid(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
var coordinates = new EntityCoordinates(grid.GridEntityId, 0, 0);
human = entityManager.SpawnEntity(BuckleDummyId, coordinates); human = entityManager.SpawnEntity(BuckleDummyId, coordinates);
chair = entityManager.SpawnEntity(StrapDummyId, coordinates); chair = entityManager.SpawnEntity(StrapDummyId, coordinates);
@@ -209,13 +207,15 @@ namespace Content.IntegrationTests.Tests.Buckle
Assert.Null(buckle.BuckledTo); Assert.Null(buckle.BuckledTo);
Assert.IsEmpty(strap.BuckledEntities); Assert.IsEmpty(strap.BuckledEntities);
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task BuckledDyingDropItemsTest() public async Task BuckledDyingDropItemsTest()
{ {
var options = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
EntityUid human = default; EntityUid human = default;
BuckleComponent buckle = null; BuckleComponent buckle = null;
@@ -229,8 +229,7 @@ namespace Content.IntegrationTests.Tests.Buckle
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
var entityManager = IoCManager.Resolve<IEntityManager>(); var entityManager = IoCManager.Resolve<IEntityManager>();
var grid = GetMainGrid(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
var coordinates = new EntityCoordinates(grid.GridEntityId, 0, 0);
human = entityManager.SpawnEntity(BuckleDummyId, coordinates); human = entityManager.SpawnEntity(BuckleDummyId, coordinates);
var chair = entityManager.SpawnEntity(StrapDummyId, coordinates); var chair = entityManager.SpawnEntity(StrapDummyId, coordinates);
@@ -292,16 +291,15 @@ namespace Content.IntegrationTests.Tests.Buckle
buckle.TryUnbuckle(human, true); buckle.TryUnbuckle(human, true);
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task ForceUnbuckleBuckleTest() public async Task ForceUnbuckleBuckleTest()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
};
var server = StartServer(options);
EntityUid human = default; EntityUid human = default;
EntityUid chair = default; EntityUid chair = default;
@@ -312,8 +310,7 @@ namespace Content.IntegrationTests.Tests.Buckle
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
var entityManager = IoCManager.Resolve<IEntityManager>(); var entityManager = IoCManager.Resolve<IEntityManager>();
var grid = GetMainGrid(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
var coordinates = new EntityCoordinates(grid.GridEntityId, 0, 0);
human = entityManager.SpawnEntity(BuckleDummyId, coordinates); human = entityManager.SpawnEntity(BuckleDummyId, coordinates);
chair = entityManager.SpawnEntity(StrapDummyId, coordinates); chair = entityManager.SpawnEntity(StrapDummyId, coordinates);
@@ -331,7 +328,7 @@ namespace Content.IntegrationTests.Tests.Buckle
entityManager.GetComponent<TransformComponent>(human).WorldPosition += (100, 0); entityManager.GetComponent<TransformComponent>(human).WorldPosition += (100, 0);
}); });
await WaitUntil(server, () => !buckle.Buckled, 10); await PoolManager.WaitUntil(server, () => !buckle.Buckled, 10);
Assert.False(buckle.Buckled); Assert.False(buckle.Buckled);
@@ -356,6 +353,7 @@ namespace Content.IntegrationTests.Tests.Buckle
Assert.NotNull(buckle.BuckledTo); Assert.NotNull(buckle.BuckledTo);
Assert.True(buckle.Buckled); Assert.True(buckle.Buckled);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

51
Content.IntegrationTests/Tests/Chemistry/SolutionSystemTests.cs
View File

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests.Chemistry;
// reactions can change this assumption // reactions can change this assumption
[TestFixture] [TestFixture]
[TestOf(typeof(SolutionContainerSystem))] [TestOf(typeof(SolutionContainerSystem))]
public sealed class SolutionSystemTests : ContentIntegrationTest public sealed class SolutionSystemTests
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -25,22 +25,19 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
beaker: beaker:
maxVol: 50 maxVol: 50
"; ";
[Test] [Test]
public async Task TryAddTwoNonReactiveReagent() public async Task TryAddTwoNonReactiveReagent()
{ {
var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
EntityUid beaker; EntityUid beaker;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var oilQuantity = FixedPoint2.New(15); var oilQuantity = FixedPoint2.New(15);
var waterQuantity = FixedPoint2.New(10); var waterQuantity = FixedPoint2.New(10);
@@ -62,7 +59,7 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
Assert.That(oil, Is.EqualTo(oilQuantity)); Assert.That(oil, Is.EqualTo(oilQuantity));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
// This test mimics current behavior // This test mimics current behavior
@@ -70,18 +67,16 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
[Test] [Test]
public async Task TryAddTooMuchNonReactiveReagent() public async Task TryAddTooMuchNonReactiveReagent()
{ {
var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
EntityUid beaker; EntityUid beaker;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var oilQuantity = FixedPoint2.New(1500); var oilQuantity = FixedPoint2.New(1500);
var waterQuantity = FixedPoint2.New(10); var waterQuantity = FixedPoint2.New(10);
@@ -103,25 +98,23 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
Assert.That(oil, Is.EqualTo(FixedPoint2.Zero)); Assert.That(oil, Is.EqualTo(FixedPoint2.Zero));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
// Unlike TryAddSolution this adds and two solution without then splits leaving only threshold in original // Unlike TryAddSolution this adds and two solution without then splits leaving only threshold in original
[Test] [Test]
public async Task TryMixAndOverflowTooMuchReagent() public async Task TryMixAndOverflowTooMuchReagent()
{ {
var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
EntityUid beaker; EntityUid beaker;
server.Assert(() => await server.WaitAssertion(() =>
{ {
int ratio = 9; int ratio = 9;
int threshold = 20; int threshold = 20;
@@ -152,25 +145,23 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
Assert.That(oilOverFlow, Is.EqualTo(oilQuantity - oilMix)); Assert.That(oilOverFlow, Is.EqualTo(oilQuantity - oilMix));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
// TryMixAndOverflow will fail if Threshold larger than MaxVolume // TryMixAndOverflow will fail if Threshold larger than MaxVolume
[Test] [Test]
public async Task TryMixAndOverflowTooBigOverflow() public async Task TryMixAndOverflowTooBigOverflow()
{ {
var options = new ServerContentIntegrationOption { ExtraPrototypes = Prototypes }; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
EntityUid beaker; EntityUid beaker;
server.Assert(() => await server.WaitAssertion(() =>
{ {
int ratio = 9; int ratio = 9;
int threshold = 60; int threshold = 60;
@@ -190,6 +181,6 @@ public sealed class SolutionSystemTests : ContentIntegrationTest
Is.False); Is.False);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }

18
Content.IntegrationTests/Tests/Chemistry/TryAllReactionsTest.cs
View File

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests.Chemistry
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(ReactionPrototype))] [TestOf(typeof(ReactionPrototype))]
public sealed class TryAllReactionsTest : ContentIntegrationTest public sealed class TryAllReactionsTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -24,19 +24,16 @@ namespace Content.IntegrationTests.Tests.Chemistry
solutions: solutions:
beaker: beaker:
maxVol: 50"; maxVol: 50";
[Test] [Test]
public async Task TryAllTest() public async Task TryAllTest()
{ {
var options = new ServerContentIntegrationOption{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var prototypeManager = server.ResolveDependency<IPrototypeManager>(); var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
foreach (var reactionPrototype in prototypeManager.EnumeratePrototypes<ReactionPrototype>()) foreach (var reactionPrototype in prototypeManager.EnumeratePrototypes<ReactionPrototype>())
{ {
@@ -46,7 +43,7 @@ namespace Content.IntegrationTests.Tests.Chemistry
EntityUid beaker; EntityUid beaker;
Solution component = null; Solution component = null;
server.Assert(() => await server.WaitAssertion(() =>
{ {
beaker = entityManager.SpawnEntity("TestSolutionContainer", coordinates); beaker = entityManager.SpawnEntity("TestSolutionContainer", coordinates);
Assert.That(EntitySystem.Get<SolutionContainerSystem>() Assert.That(EntitySystem.Get<SolutionContainerSystem>()
@@ -63,7 +60,7 @@ namespace Content.IntegrationTests.Tests.Chemistry
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => await server.WaitAssertion(() =>
{ {
//you just got linq'd fool //you just got linq'd fool
//(i'm sorry) //(i'm sorry)
@@ -78,8 +75,9 @@ namespace Content.IntegrationTests.Tests.Chemistry
Assert.That(foundProductsMap.All(x => x.Value)); Assert.That(foundProductsMap.All(x => x.Value));
}); });
}
}
await pairTracker.CleanReturnAsync();
} }
} }

42
Content.IntegrationTests/Tests/ClickableTest.cs
View File

@@ -4,37 +4,20 @@ using Content.Client.Clickable;
using NUnit.Framework; using NUnit.Framework;
using Robust.Client.Graphics; using Robust.Client.Graphics;
using Robust.Server.GameObjects; using Robust.Server.GameObjects;
using Robust.Shared;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.Map; using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class ClickableTest : ContentIntegrationTest public sealed class ClickableTest
{ {
private ClientIntegrationInstance _client;
private ServerIntegrationInstance _server;
private const double DirSouth = 0; private const double DirSouth = 0;
private const double DirNorth = Math.PI; private const double DirNorth = Math.PI;
private const double DirEast = Math.PI / 2; private const double DirEast = Math.PI / 2;
private const double DirSouthEast = Math.PI / 4; private const double DirSouthEast = Math.PI / 4;
private const double DirSouthEastJustShy = Math.PI / 4 - 0.1; private const double DirSouthEastJustShy = Math.PI / 4 - 0.1;
[OneTimeSetUp]
public async Task Setup()
{
(_client, _server) = await StartConnectedServerClientPair(serverOptions: new ServerContentIntegrationOption()
{
CVarOverrides =
{
[CVars.NetPVS.Name] = "false"
}
});
}
[Parallelizable(ParallelScope.None)]
[Test] [Test]
[TestCase("ClickTestRotatingCornerVisible", 0.25f, 0.25f, DirSouth, 1, ExpectedResult = true)] [TestCase("ClickTestRotatingCornerVisible", 0.25f, 0.25f, DirSouth, 1, ExpectedResult = true)]
[TestCase("ClickTestRotatingCornerVisible", 0.35f, 0.5f, DirSouth, 2, ExpectedResult = true)] [TestCase("ClickTestRotatingCornerVisible", 0.35f, 0.5f, DirSouth, 2, ExpectedResult = true)]
@@ -64,26 +47,29 @@ namespace Content.IntegrationTests.Tests
[TestCase("ClickTestRotatingCornerInvisibleNoRot", 0.25f, 0.25f, DirSouthEastJustShy, 1, ExpectedResult = true)] [TestCase("ClickTestRotatingCornerInvisibleNoRot", 0.25f, 0.25f, DirSouthEastJustShy, 1, ExpectedResult = true)]
public async Task<bool> Test(string prototype, float clickPosX, float clickPosY, double angle, float scale) public async Task<bool> Test(string prototype, float clickPosX, float clickPosY, double angle, float scale)
{ {
await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var client = pairTracker.Pair.Client;
EntityUid entity = default; EntityUid entity = default;
var clientEntManager = _client.ResolveDependency<IEntityManager>(); var clientEntManager = client.ResolveDependency<IEntityManager>();
var serverEntManager = _server.ResolveDependency<IEntityManager>(); var serverEntManager = server.ResolveDependency<IEntityManager>();
var eyeManager = _client.ResolveDependency<IEyeManager>(); var eyeManager = client.ResolveDependency<IEyeManager>();
var mapManager = _server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
await _server.WaitPost(() => await server.WaitPost(() =>
{ {
var ent = serverEntManager.SpawnEntity(prototype, GetMainEntityCoordinates(mapManager)); var ent = serverEntManager.SpawnEntity(prototype, PoolManager.GetMainEntityCoordinates(mapManager));
serverEntManager.GetComponent<TransformComponent>(ent).WorldRotation = angle; serverEntManager.GetComponent<TransformComponent>(ent).WorldRotation = angle;
serverEntManager.GetComponent<SpriteComponent>(ent).Scale = (scale, scale); serverEntManager.GetComponent<SpriteComponent>(ent).Scale = (scale, scale);
entity = ent; entity = ent;
}); });
// Let client sync up. // Let client sync up.
await RunTicksSync(_client, _server, 5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
var hit = false; var hit = false;
await _client.WaitPost(() => await client.WaitPost(() =>
{ {
// these tests currently all assume player eye is 0 // these tests currently all assume player eye is 0
eyeManager.CurrentEye.Rotation = 0; eyeManager.CurrentEye.Rotation = 0;
@@ -94,11 +80,13 @@ namespace Content.IntegrationTests.Tests
hit = clickable.CheckClick((clickPosX, clickPosY) + pos, out _, out _); hit = clickable.CheckClick((clickPosX, clickPosY) + pos, out _, out _);
}); });
await _server.WaitPost(() => await server.WaitPost(() =>
{ {
serverEntManager.DeleteEntity(entity); serverEntManager.DeleteEntity(entity);
}); });
await pairTracker.CleanReturnAsync();
return hit; return hit;
} }
} }

8
Content.IntegrationTests/Tests/Commands/PardonCommand.cs
View File

@@ -10,16 +10,15 @@ namespace Content.IntegrationTests.Tests.Commands
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(PardonCommand))] [TestOf(typeof(PardonCommand))]
public sealed class PardonCommand : ContentIntegrationTest public sealed class PardonCommand
{ {
private static readonly TimeSpan MarginOfError = TimeSpan.FromMinutes(1); private static readonly TimeSpan MarginOfError = TimeSpan.FromMinutes(1);
[Test] [Test]
public async Task PardonTest() public async Task PardonTest()
{ {
var (client, server) = await StartConnectedServerClientPair(); await using var pairTracker = await PoolManager.GetServerClient(new (){Destructive = true});
var server = pairTracker.Pair.Server;
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sPlayerManager = server.ResolveDependency<IPlayerManager>(); var sPlayerManager = server.ResolveDependency<IPlayerManager>();
var sConsole = server.ResolveDependency<IServerConsoleHost>(); var sConsole = server.ResolveDependency<IServerConsoleHost>();
@@ -122,6 +121,7 @@ namespace Content.IntegrationTests.Tests.Commands
// The list is still returned since that ignores pardons // The list is still returned since that ignores pardons
Assert.That(await sDatabase.GetServerBansAsync(null, clientId, null), Has.Count.EqualTo(1)); Assert.That(await sDatabase.GetServerBansAsync(null, clientId, null), Has.Count.EqualTo(1));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

7
Content.IntegrationTests/Tests/Commands/RejuvenateTest.cs
View File

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests.Commands
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(RejuvenateCommand))] [TestOf(typeof(RejuvenateCommand))]
public sealed class RejuvenateTest : ContentIntegrationTest public sealed class RejuvenateTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -33,8 +33,8 @@ namespace Content.IntegrationTests.Tests.Commands
[Test] [Test]
public async Task RejuvenateDeadTest() public async Task RejuvenateDeadTest()
{ {
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -78,6 +78,7 @@ namespace Content.IntegrationTests.Tests.Commands
Assert.That(damageable.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(damageable.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

26
Content.IntegrationTests/Tests/Commands/RestartRoundTest.cs
View File

@@ -12,33 +12,27 @@ namespace Content.IntegrationTests.Tests.Commands
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(RestartRoundNowCommand))] [TestOf(typeof(RestartRoundNowCommand))]
public sealed class RestartRoundNowTest : ContentIntegrationTest public sealed class RestartRoundNowTest
{ {
[Test] [Test]
[TestCase(true)] [TestCase(true)]
[TestCase(false)] [TestCase(false)]
public async Task RestartRoundAfterStart(bool lobbyEnabled) public async Task RestartRoundAfterStart(bool lobbyEnabled)
{ {
var (_, server) = await StartConnectedServerClientPair(serverOptions: new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings(){Dirty = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{
[CCVars.GameMap.Name] = "saltern"
}
});
await server.WaitIdleAsync();
var configManager = server.ResolveDependency<IConfigurationManager>(); var configManager = server.ResolveDependency<IConfigurationManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
var gameTicker = entityManager.EntitySysManager.GetEntitySystem<GameTicker>(); var gameTicker = entityManager.EntitySysManager.GetEntitySystem<GameTicker>();
await server.WaitRunTicks(30); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
GameTick tickBeforeRestart = default; GameTick tickBeforeRestart = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(configManager.GetCVar<bool>(CCVars.GameLobbyEnabled), Is.EqualTo(false));
configManager.SetCVar(CCVars.GameLobbyEnabled, lobbyEnabled); configManager.SetCVar(CCVars.GameLobbyEnabled, lobbyEnabled);
Assert.That(gameTicker.RunLevel, Is.EqualTo(GameRunLevel.InRound)); Assert.That(gameTicker.RunLevel, Is.EqualTo(GameRunLevel.InRound));
@@ -54,17 +48,17 @@ namespace Content.IntegrationTests.Tests.Commands
} }
}); });
await server.WaitIdleAsync(); await PoolManager.RunTicksSync(pairTracker.Pair, 15);
await server.WaitRunTicks(5);
server.Assert(() => await server.WaitAssertion(() =>
{ {
var tickAfterRestart = entityManager.CurrentTick; var tickAfterRestart = entityManager.CurrentTick;
Assert.That(tickBeforeRestart < tickAfterRestart); Assert.That(tickBeforeRestart < tickAfterRestart);
}); });
await server.WaitRunTicks(60); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await pairTracker.CleanReturnAsync();
} }
} }
} }

20
Content.IntegrationTests/Tests/Construction/ConstructionActionValid.cs
View File

@@ -9,7 +9,7 @@ using Robust.Shared.Prototypes;
namespace Content.IntegrationTests.Tests.Construction namespace Content.IntegrationTests.Tests.Construction
{ {
[TestFixture] [TestFixture]
public sealed class ConstructionActionValid : ContentIntegrationTest public sealed class ConstructionActionValid
{ {
private bool IsValid(IGraphAction action, IPrototypeManager protoMan, out string prototype) private bool IsValid(IGraphAction action, IPrototypeManager protoMan, out string prototype)
{ {
@@ -49,9 +49,8 @@ namespace Content.IntegrationTests.Tests.Construction
[Test] [Test]
public async Task ConstructionGraphSpawnPrototypeValid() public async Task ConstructionGraphSpawnPrototypeValid()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -82,6 +81,7 @@ namespace Content.IntegrationTests.Tests.Construction
} }
} }
} }
await pairTracker.CleanReturnAsync();
Assert.That(valid, Is.True, $"One or more SpawnPrototype actions specified invalid entity prototypes!\n{message}"); Assert.That(valid, Is.True, $"One or more SpawnPrototype actions specified invalid entity prototypes!\n{message}");
} }
@@ -89,9 +89,8 @@ namespace Content.IntegrationTests.Tests.Construction
[Test] [Test]
public async Task ConstructionGraphNodeEntityPrototypeValid() public async Task ConstructionGraphNodeEntityPrototypeValid()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -108,6 +107,7 @@ namespace Content.IntegrationTests.Tests.Construction
message.Append($"Invalid entity prototype \"{node.Entity}\" on node \"{node.Name}\" of graph \"{graph.ID}\"\n"); message.Append($"Invalid entity prototype \"{node.Entity}\" on node \"{node.Name}\" of graph \"{graph.ID}\"\n");
} }
} }
await pairTracker.CleanReturnAsync();
Assert.That(valid, Is.True, $"One or more nodes specified invalid entity prototypes!\n{message}"); Assert.That(valid, Is.True, $"One or more nodes specified invalid entity prototypes!\n{message}");
} }
@@ -115,9 +115,8 @@ namespace Content.IntegrationTests.Tests.Construction
[Test] [Test]
public async Task ConstructionGraphEdgeValid() public async Task ConstructionGraphEdgeValid()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -139,6 +138,7 @@ namespace Content.IntegrationTests.Tests.Construction
} }
Assert.That(valid, Is.True, $"One or more edges specified invalid node targets!\n{message}"); Assert.That(valid, Is.True, $"One or more edges specified invalid node targets!\n{message}");
await pairTracker.CleanReturnAsync();
} }
} }
} }

20
Content.IntegrationTests/Tests/Construction/ConstructionPrototypeTest.cs
View File

@@ -6,7 +6,7 @@ using Robust.Shared.Prototypes;
namespace Content.IntegrationTests.Tests.Construction namespace Content.IntegrationTests.Tests.Construction
{ {
[TestFixture] [TestFixture]
public sealed class ConstructionPrototypeTest : ContentIntegrationTest public sealed class ConstructionPrototypeTest
{ {
// discount linter for construction graphs // discount linter for construction graphs
// TODO: Create serialization validators for these? // TODO: Create serialization validators for these?
@@ -14,9 +14,8 @@ namespace Content.IntegrationTests.Tests.Construction
[Test] [Test]
public async Task TestStartIsValid() public async Task TestStartIsValid()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -27,14 +26,14 @@ namespace Content.IntegrationTests.Tests.Construction
Assert.That(graph.Nodes.ContainsKey(start), $"Found no startNode \"{start}\" on graph \"{graph.ID}\" for construction prototype \"{proto.ID}\"!"); Assert.That(graph.Nodes.ContainsKey(start), $"Found no startNode \"{start}\" on graph \"{graph.ID}\" for construction prototype \"{proto.ID}\"!");
} }
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestTargetIsValid() public async Task TestTargetIsValid()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -45,14 +44,14 @@ namespace Content.IntegrationTests.Tests.Construction
Assert.That(graph.Nodes.ContainsKey(target), $"Found no targetNode \"{target}\" on graph \"{graph.ID}\" for construction prototype \"{proto.ID}\"!"); Assert.That(graph.Nodes.ContainsKey(target), $"Found no targetNode \"{target}\" on graph \"{graph.ID}\" for construction prototype \"{proto.ID}\"!");
} }
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestStartReachesValidTarget() public async Task TestStartReachesValidTarget()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var protoMan = server.ResolveDependency<IPrototypeManager>(); var protoMan = server.ResolveDependency<IPrototypeManager>();
@@ -68,6 +67,7 @@ namespace Content.IntegrationTests.Tests.Construction
Assert.That(protoMan.TryIndex(next.Entity, out EntityPrototype entity), $"The next node ({next.Name}) in the path from the start node ({start}) to the target node ({target}) specified an invalid entity prototype ({next.Entity})"); Assert.That(protoMan.TryIndex(next.Entity, out EntityPrototype entity), $"The next node ({next.Name}) in the path from the start node ({start}) to the target node ({target}) specified an invalid entity prototype ({next.Entity})");
Assert.That(entity.Components.ContainsKey("Construction"), $"The next node ({next.Name}) in the path from the start node ({start}) to the target node ({target}) specified an entity prototype ({next.Entity}) without a ConstructionComponent."); Assert.That(entity.Components.ContainsKey("Construction"), $"The next node ({next.Name}) in the path from the start node ({start}) to the target node ({target}) specified an entity prototype ({next.Entity}) without a ConstructionComponent.");
} }
await pairTracker.CleanReturnAsync();
} }
} }
} }

94
Content.IntegrationTests/Tests/ContainerOcclusionTest.cs
View File

@@ -3,8 +3,6 @@ using System.Threading.Tasks;
using Content.Server.Storage.Components; using Content.Server.Storage.Components;
using NUnit.Framework; using NUnit.Framework;
using Robust.Client.GameObjects; using Robust.Client.GameObjects;
using Robust.Server.Player;
using Robust.Shared;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.IoC; using Robust.Shared.IoC;
using Robust.Shared.Map; using Robust.Shared.Map;
@@ -12,9 +10,9 @@ using Robust.Shared.Maths;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
public sealed class ContainerOcclusionTest : ContentIntegrationTest public sealed class ContainerOcclusionTest
{ {
private const string ExtraPrototypes = @" private const string Prototypes = @"
- type: entity - type: entity
id: ContainerOcclusionA id: ContainerOcclusionA
components: components:
@@ -35,53 +33,21 @@ namespace Content.IntegrationTests.Tests
- type: PointLight - type: PointLight
"; ";
private async Task<(ClientIntegrationInstance c, ServerIntegrationInstance s)> Start()
{
var optsServer = new ServerIntegrationOptions
{
CVarOverrides =
{
{CVars.NetPVS.Name, "false"}
},
ExtraPrototypes = ExtraPrototypes
};
var optsClient = new ClientIntegrationOptions
{
CVarOverrides =
{
{CVars.NetPVS.Name, "false"}
},
ExtraPrototypes = ExtraPrototypes
};
var (c, s) = await StartConnectedServerDummyTickerClientPair(optsClient, optsServer);
s.Post(() =>
{
IoCManager.Resolve<IPlayerManager>().ServerSessions.Single().JoinGame();
var mapMan = IoCManager.Resolve<IMapManager>();
mapMan.CreateMap(new MapId(1));
});
return (c, s);
}
[Test] [Test]
public async Task TestA() public async Task TestA()
{ {
var (c, s) = await Start(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{ExtraPrototypes = Prototypes});
var s = pairTracker.Pair.Server;
await c.WaitIdleAsync(); var c = pairTracker.Pair.Client;
var cEntities = c.ResolveDependency<IEntityManager>(); var cEntities = c.ResolveDependency<IEntityManager>();
EntityUid dummy = default; EntityUid dummy = default;
s.Post(() => var ent2 = s.ResolveDependency<IMapManager>();
await s.WaitPost(() =>
{ {
var pos = new MapCoordinates(Vector2.Zero, new MapId(1)); var mapId = ent2.GetAllMapIds().Last();
var pos = new MapCoordinates(Vector2.Zero, mapId);
var ent = IoCManager.Resolve<IEntityManager>(); var ent = IoCManager.Resolve<IEntityManager>();
var container = ent.SpawnEntity("ContainerOcclusionA", pos); var container = ent.SpawnEntity("ContainerOcclusionA", pos);
dummy = ent.SpawnEntity("ContainerOcclusionDummy", pos); dummy = ent.SpawnEntity("ContainerOcclusionDummy", pos);
@@ -89,9 +55,9 @@ namespace Content.IntegrationTests.Tests
ent.GetComponent<EntityStorageComponent>(container).Insert(dummy); ent.GetComponent<EntityStorageComponent>(container).Insert(dummy);
}); });
await RunTicksSync(c, s, 5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
c.Assert(() => await c.WaitAssertion(() =>
{ {
var sprite = cEntities.GetComponent<SpriteComponent>(dummy); var sprite = cEntities.GetComponent<SpriteComponent>(dummy);
var light = cEntities.GetComponent<PointLightComponent>(dummy); var light = cEntities.GetComponent<PointLightComponent>(dummy);
@@ -99,22 +65,24 @@ namespace Content.IntegrationTests.Tests
Assert.True(light.ContainerOccluded); Assert.True(light.ContainerOccluded);
}); });
await Task.WhenAll(c.WaitIdleAsync(), s.WaitIdleAsync()); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestB() public async Task TestB()
{ {
var (c, s) = await Start(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{ExtraPrototypes = Prototypes});
var s = pairTracker.Pair.Server;
await c.WaitIdleAsync(); var c = pairTracker.Pair.Client;
var cEntities = c.ResolveDependency<IEntityManager>(); var cEntities = c.ResolveDependency<IEntityManager>();
var ent2 = s.ResolveDependency<IMapManager>();
EntityUid dummy = default; EntityUid dummy = default;
s.Post(() => await s.WaitPost(() =>
{ {
var pos = new MapCoordinates(Vector2.Zero, new MapId(1)); var mapId = ent2.GetAllMapIds().Last();
var pos = new MapCoordinates(Vector2.Zero, mapId);
var ent = IoCManager.Resolve<IEntityManager>(); var ent = IoCManager.Resolve<IEntityManager>();
var container = ent.SpawnEntity("ContainerOcclusionB", pos); var container = ent.SpawnEntity("ContainerOcclusionB", pos);
dummy = ent.SpawnEntity("ContainerOcclusionDummy", pos); dummy = ent.SpawnEntity("ContainerOcclusionDummy", pos);
@@ -122,9 +90,9 @@ namespace Content.IntegrationTests.Tests
ent.GetComponent<EntityStorageComponent>(container).Insert(dummy); ent.GetComponent<EntityStorageComponent>(container).Insert(dummy);
}); });
await RunTicksSync(c, s, 5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
c.Assert(() => await c.WaitAssertion(() =>
{ {
var sprite = cEntities.GetComponent<SpriteComponent>(dummy); var sprite = cEntities.GetComponent<SpriteComponent>(dummy);
var light = cEntities.GetComponent<PointLightComponent>(dummy); var light = cEntities.GetComponent<PointLightComponent>(dummy);
@@ -132,22 +100,24 @@ namespace Content.IntegrationTests.Tests
Assert.False(light.ContainerOccluded); Assert.False(light.ContainerOccluded);
}); });
await Task.WhenAll(c.WaitIdleAsync(), s.WaitIdleAsync()); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestAb() public async Task TestAb()
{ {
var (c, s) = await Start(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{ExtraPrototypes = Prototypes});
var s = pairTracker.Pair.Server;
await c.WaitIdleAsync(); var c = pairTracker.Pair.Client;
var ent2 = s.ResolveDependency<IMapManager>();
var cEntities = c.ResolveDependency<IEntityManager>(); var cEntities = c.ResolveDependency<IEntityManager>();
EntityUid dummy = default; EntityUid dummy = default;
s.Post(() => await s.WaitPost(() =>
{ {
var pos = new MapCoordinates(Vector2.Zero, new MapId(1)); var mapId = ent2.GetAllMapIds().Last();
var pos = new MapCoordinates(Vector2.Zero, mapId);
var ent = IoCManager.Resolve<IEntityManager>(); var ent = IoCManager.Resolve<IEntityManager>();
var containerA = ent.SpawnEntity("ContainerOcclusionA", pos); var containerA = ent.SpawnEntity("ContainerOcclusionA", pos);
var containerB = ent.SpawnEntity("ContainerOcclusionB", pos); var containerB = ent.SpawnEntity("ContainerOcclusionB", pos);
@@ -157,9 +127,9 @@ namespace Content.IntegrationTests.Tests
ent.GetComponent<EntityStorageComponent>(containerB).Insert(dummy); ent.GetComponent<EntityStorageComponent>(containerB).Insert(dummy);
}); });
await RunTicksSync(c, s, 5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
c.Assert(() => await c.WaitAssertion(() =>
{ {
var sprite = cEntities.GetComponent<SpriteComponent>(dummy); var sprite = cEntities.GetComponent<SpriteComponent>(dummy);
var light = cEntities.GetComponent<PointLightComponent>(dummy); var light = cEntities.GetComponent<PointLightComponent>(dummy);
@@ -167,7 +137,7 @@ namespace Content.IntegrationTests.Tests
Assert.True(light.ContainerOccluded); Assert.True(light.ContainerOccluded);
}); });
await Task.WhenAll(c.WaitIdleAsync(), s.WaitIdleAsync()); await pairTracker.CleanReturnAsync();
} }
} }
} }

2
Content.IntegrationTests/Tests/Damageable/DamageSpecifierTest.cs
View File

@@ -7,7 +7,7 @@ namespace Content.IntegrationTests.Tests.Damageable;
[TestFixture] [TestFixture]
[TestOf(typeof(DamageSpecifier))] [TestOf(typeof(DamageSpecifier))]
public sealed class DamageSpecifierTest : ContentIntegrationTest public sealed class DamageSpecifierTest
{ {
[Test] [Test]
public void TestDamageSpecifierOperations() public void TestDamageSpecifierOperations()

37
Content.IntegrationTests/Tests/Damageable/DamageableTest.cs
View File

@@ -14,9 +14,9 @@ namespace Content.IntegrationTests.Tests.Damageable
[TestFixture] [TestFixture]
[TestOf(typeof(DamageableComponent))] [TestOf(typeof(DamageableComponent))]
[TestOf(typeof(DamageableSystem))] [TestOf(typeof(DamageableSystem))]
public sealed class DamageableTest : ContentIntegrationTest public sealed class DamageableTest
{ {
private const string Prototypes = @" public const string Prototypes = @"
# Define some damage groups # Define some damage groups
- type: damageType - type: damageType
id: TestDamage1 id: TestDamage1
@@ -71,30 +71,17 @@ namespace Content.IntegrationTests.Tests.Damageable
damageContainer: testDamageContainer damageContainer: testDamageContainer
"; ";
// public bool & function to determine whether dealing damage resulted in actual damage change
public bool DamageChanged = false;
public void DamageChangedListener(EntityUid _, DamageableComponent comp, DamageChangedEvent args)
{
DamageChanged = true;
}
[Test] [Test]
public async Task TestDamageableComponents() public async Task TestDamageableComponents()
{ {
var server = StartServerDummyTicker(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
var sPrototypeManager = server.ResolveDependency<IPrototypeManager>(); var sPrototypeManager = server.ResolveDependency<IPrototypeManager>();
var sEntitySystemManager = server.ResolveDependency<IEntitySystemManager>(); var sEntitySystemManager = server.ResolveDependency<IEntitySystemManager>();
sEntityManager.EventBus.SubscribeLocalEvent<DamageableComponent, DamageChangedEvent>(DamageChangedListener);
EntityUid sDamageableEntity = default; EntityUid sDamageableEntity = default;
DamageableComponent sDamageableComponent = null; DamageableComponent sDamageableComponent = null;
DamageableSystem sDamageableSystem = null; DamageableSystem sDamageableSystem = null;
@@ -153,8 +140,7 @@ namespace Content.IntegrationTests.Tests.Damageable
DamageSpecifier damage = new(group3, damageToDeal); DamageSpecifier damage = new(group3, damageToDeal);
sDamageableSystem.TryChangeDamage(uid, damage, true); sDamageableSystem.TryChangeDamage(uid, damage, true);
Assert.That(DamageChanged);
DamageChanged = false;
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal));
Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(damageToDeal)); Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(damageToDeal));
foreach (var type in types) foreach (var type in types)
@@ -165,8 +151,7 @@ namespace Content.IntegrationTests.Tests.Damageable
// Heal // Heal
sDamageableSystem.TryChangeDamage(uid, -damage); sDamageableSystem.TryChangeDamage(uid, -damage);
Assert.That(DamageChanged);
DamageChanged = false;
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(FixedPoint2.Zero));
foreach (var type in types) foreach (var type in types)
@@ -180,8 +165,7 @@ namespace Content.IntegrationTests.Tests.Damageable
damageToDeal = FixedPoint2.New(types.Count() * 5 - 1); damageToDeal = FixedPoint2.New(types.Count() * 5 - 1);
damage = new DamageSpecifier(group3, damageToDeal); damage = new DamageSpecifier(group3, damageToDeal);
sDamageableSystem.TryChangeDamage(uid, damage, true); sDamageableSystem.TryChangeDamage(uid, damage, true);
Assert.That(DamageChanged);
DamageChanged = false;
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(damageToDeal));
Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(damageToDeal)); Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(damageToDeal));
Assert.That(sDamageableComponent.Damage.DamageDict[type3a.ID], Is.EqualTo(damageToDeal / types.Count())); Assert.That(sDamageableComponent.Damage.DamageDict[type3a.ID], Is.EqualTo(damageToDeal / types.Count()));
@@ -192,8 +176,6 @@ namespace Content.IntegrationTests.Tests.Damageable
// Heal // Heal
sDamageableSystem.TryChangeDamage(uid, -damage); sDamageableSystem.TryChangeDamage(uid, -damage);
Assert.That(DamageChanged);
DamageChanged = false;
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.DamagePerGroup[group3.ID], Is.EqualTo(FixedPoint2.Zero));
foreach (var type in types) foreach (var type in types)
@@ -206,7 +188,6 @@ namespace Content.IntegrationTests.Tests.Damageable
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
damage = new DamageSpecifier(group1, FixedPoint2.New(10)) + new DamageSpecifier(type2b, FixedPoint2.New(10)); damage = new DamageSpecifier(group1, FixedPoint2.New(10)) + new DamageSpecifier(type2b, FixedPoint2.New(10));
sDamageableSystem.TryChangeDamage(uid, damage, true); sDamageableSystem.TryChangeDamage(uid, damage, true);
Assert.That(DamageChanged, Is.False);
Assert.That(sDamageableComponent.DamagePerGroup.TryGetValue(group1.ID, out groupDamage), Is.False); Assert.That(sDamageableComponent.DamagePerGroup.TryGetValue(group1.ID, out groupDamage), Is.False);
Assert.That(sDamageableComponent.Damage.DamageDict.TryGetValue(type1.ID, out typeDamage), Is.False); Assert.That(sDamageableComponent.Damage.DamageDict.TryGetValue(type1.ID, out typeDamage), Is.False);
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
@@ -227,15 +208,13 @@ namespace Content.IntegrationTests.Tests.Damageable
// Test Over-Healing // Test Over-Healing
sDamageableSystem.TryChangeDamage(uid, new DamageSpecifier(group3, FixedPoint2.New(-100))); sDamageableSystem.TryChangeDamage(uid, new DamageSpecifier(group3, FixedPoint2.New(-100)));
Assert.That(DamageChanged);
DamageChanged = false;
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
// Test that if no health change occurred, returns false // Test that if no health change occurred, returns false
sDamageableSystem.TryChangeDamage(uid, new DamageSpecifier(group3, -100)); sDamageableSystem.TryChangeDamage(uid, new DamageSpecifier(group3, -100));
Assert.That(DamageChanged, Is.False);
Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero)); Assert.That(sDamageableComponent.TotalDamage, Is.EqualTo(FixedPoint2.Zero));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

6
Content.IntegrationTests/Tests/DeleteInventoryTest.cs
View File

@@ -11,14 +11,15 @@ using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class DeleteInventoryTest : ContentIntegrationTest public sealed class DeleteInventoryTest
{ {
// Test that when deleting an entity with an InventoryComponent, // Test that when deleting an entity with an InventoryComponent,
// any equipped items also get deleted. // any equipped items also get deleted.
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -46,6 +47,7 @@ namespace Content.IntegrationTests.Tests
// Assert that child item was also deleted. // Assert that child item was also deleted.
Assert.That(item.Deleted, Is.True); Assert.That(item.Deleted, Is.True);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

14
Content.IntegrationTests/Tests/Destructible/DestructibleDamageGroupTest.cs
View File

@@ -15,17 +15,13 @@ namespace Content.IntegrationTests.Tests.Destructible
[TestFixture] [TestFixture]
[TestOf(typeof(DamageGroupTrigger))] [TestOf(typeof(DamageGroupTrigger))]
[TestOf(typeof(AndTrigger))] [TestOf(typeof(AndTrigger))]
public sealed class DestructibleDamageGroupTest : ContentIntegrationTest public sealed class DestructibleDamageGroupTest
{ {
[Test] [Test]
public async Task AndTest() public async Task AndTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
@@ -39,8 +35,7 @@ namespace Content.IntegrationTests.Tests.Destructible
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var gridId = GetMainGrid(sMapManager).GridEntityId; var coordinates = PoolManager.GetMainEntityCoordinates(sMapManager);
var coordinates = new EntityCoordinates(gridId, 0, 0);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDamageGroupEntityId, coordinates); sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDamageGroupEntityId, coordinates);
sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity); sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity);
@@ -184,6 +179,7 @@ namespace Content.IntegrationTests.Tests.Destructible
// No new thresholds reached as triggers once is set to true and it already triggered before // No new thresholds reached as triggers once is set to true and it already triggered before
Assert.IsEmpty(sTestThresholdListenerSystem.ThresholdsReached); Assert.IsEmpty(sTestThresholdListenerSystem.ThresholdsReached);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

14
Content.IntegrationTests/Tests/Destructible/DestructibleDamageTypeTest.cs
View File

@@ -14,17 +14,13 @@ namespace Content.IntegrationTests.Tests.Destructible
[TestFixture] [TestFixture]
[TestOf(typeof(DamageTypeTrigger))] [TestOf(typeof(DamageTypeTrigger))]
[TestOf(typeof(AndTrigger))] [TestOf(typeof(AndTrigger))]
public sealed class DestructibleDamageTypeTest : ContentIntegrationTest public sealed class DestructibleDamageTypeTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
@@ -37,8 +33,7 @@ namespace Content.IntegrationTests.Tests.Destructible
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var gridId = GetMainGrid(sMapManager).GridEntityId; var coordinates = PoolManager.GetMainEntityCoordinates(sMapManager);
var coordinates = new EntityCoordinates(gridId, 0, 0);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDamageTypeEntityId, coordinates); sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDamageTypeEntityId, coordinates);
sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity); sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity);
@@ -180,6 +175,7 @@ namespace Content.IntegrationTests.Tests.Destructible
// No new thresholds reached as triggers once is set to true and it already triggered before // No new thresholds reached as triggers once is set to true and it already triggered before
Assert.IsEmpty(sTestThresholdListenerSystem.ThresholdsReached); Assert.IsEmpty(sTestThresholdListenerSystem.ThresholdsReached);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

14
Content.IntegrationTests/Tests/Destructible/DestructibleDestructionTest.cs
View File

@@ -13,17 +13,13 @@ using static Content.IntegrationTests.Tests.Destructible.DestructibleTestPrototy
namespace Content.IntegrationTests.Tests.Destructible namespace Content.IntegrationTests.Tests.Destructible
{ {
public sealed class DestructibleDestructionTest : ContentIntegrationTest public sealed class DestructibleDestructionTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
@@ -35,8 +31,7 @@ namespace Content.IntegrationTests.Tests.Destructible
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var gridId = GetMainGrid(sMapManager).GridEntityId; var coordinates = PoolManager.GetMainEntityCoordinates(sMapManager);
var coordinates = new EntityCoordinates(gridId, 0, 0);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDestructionEntityId, coordinates); sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleDestructionEntityId, coordinates);
sTestThresholdListenerSystem = sEntitySystemManager.GetEntitySystem<TestDestructibleListenerSystem>(); sTestThresholdListenerSystem = sEntitySystemManager.GetEntitySystem<TestDestructibleListenerSystem>();
@@ -87,6 +82,7 @@ namespace Content.IntegrationTests.Tests.Destructible
Assert.That(found, Is.True); Assert.That(found, Is.True);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

14
Content.IntegrationTests/Tests/Destructible/DestructibleThresholdActivationTest.cs
View File

@@ -19,17 +19,13 @@ namespace Content.IntegrationTests.Tests.Destructible
[TestFixture] [TestFixture]
[TestOf(typeof(DestructibleComponent))] [TestOf(typeof(DestructibleComponent))]
[TestOf(typeof(DamageThreshold))] [TestOf(typeof(DamageThreshold))]
public sealed class DestructibleThresholdActivationTest : ContentIntegrationTest public sealed class DestructibleThresholdActivationTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
});
await server.WaitIdleAsync();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
@@ -44,8 +40,7 @@ namespace Content.IntegrationTests.Tests.Destructible
await server.WaitPost(() => await server.WaitPost(() =>
{ {
var gridId = GetMainGrid(sMapManager).GridEntityId; var coordinates = PoolManager.GetMainEntityCoordinates(sMapManager);
var coordinates = new EntityCoordinates(gridId, 0, 0);
sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleEntityId, coordinates); sDestructibleEntity = sEntityManager.SpawnEntity(DestructibleEntityId, coordinates);
sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity); sDamageableComponent = IoCManager.Resolve<IEntityManager>().GetComponent<DamageableComponent>(sDestructibleEntity);
@@ -268,6 +263,7 @@ namespace Content.IntegrationTests.Tests.Destructible
// They shouldn't have been triggered by changing TriggersOnce // They shouldn't have been triggered by changing TriggersOnce
Assert.That(sTestThresholdListenerSystem.ThresholdsReached, Is.Empty); Assert.That(sTestThresholdListenerSystem.ThresholdsReached, Is.Empty);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

62
Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTest.cs
View File

@@ -13,7 +13,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
[TestOf(typeof(DeviceNetworkComponent))] [TestOf(typeof(DeviceNetworkComponent))]
[TestOf(typeof(WiredNetworkComponent))] [TestOf(typeof(WiredNetworkComponent))]
[TestOf(typeof(WirelessNetworkComponent))] [TestOf(typeof(WirelessNetworkComponent))]
public sealed class DeviceNetworkTest : ContentIntegrationTest public sealed class DeviceNetworkTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -50,17 +50,8 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
[Test] [Test]
public async Task NetworkDeviceSendAndReceive() public async Task NetworkDeviceSendAndReceive()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes,
ContentBeforeIoC = () => {
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<DeviceNetworkTestSystem>();
}
};
var server = StartServer(options);
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -81,7 +72,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
["testbool"] = true ["testbool"] = true
}; };
server.Assert(() => { await server.WaitAssertion(() => {
mapManager.CreateNewMapEntity(MapId.Nullspace); mapManager.CreateNewMapEntity(MapId.Nullspace);
device1 = entityManager.SpawnEntity("DummyNetworkDevice", MapCoordinates.Nullspace); device1 = entityManager.SpawnEntity("DummyNetworkDevice", MapCoordinates.Nullspace);
@@ -104,25 +95,17 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
CollectionAssert.AreEquivalent(deviceNetTestSystem.LastPayload, payload); CollectionAssert.AreEquivalent(deviceNetTestSystem.LastPayload, payload);
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task WirelessNetworkDeviceSendAndReceive() public async Task WirelessNetworkDeviceSendAndReceive()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes,
ContentBeforeIoC = () => {
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<DeviceNetworkTestSystem>();
}
};
var server = StartServer(options);
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -144,7 +127,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
["testbool"] = true ["testbool"] = true
}; };
server.Assert(() => { await server.WaitAssertion(() => {
mapManager.CreateNewMapEntity(MapId.Nullspace); mapManager.CreateNewMapEntity(MapId.Nullspace);
device1 = entityManager.SpawnEntity("DummyWirelessNetworkDevice", MapCoordinates.Nullspace); device1 = entityManager.SpawnEntity("DummyWirelessNetworkDevice", MapCoordinates.Nullspace);
@@ -168,7 +151,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
CollectionAssert.AreEqual(deviceNetTestSystem.LastPayload, payload); CollectionAssert.AreEqual(deviceNetTestSystem.LastPayload, payload);
payload = new NetworkPayload payload = new NetworkPayload
@@ -184,27 +167,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
CollectionAssert.AreNotEqual(deviceNetTestSystem.LastPayload, payload); CollectionAssert.AreNotEqual(deviceNetTestSystem.LastPayload, payload);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task WiredNetworkDeviceSendAndReceive() public async Task WiredNetworkDeviceSendAndReceive()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes,
ContentBeforeIoC = () => {
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<DeviceNetworkTestSystem>();
}
};
var server = StartServer(options);
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -230,7 +204,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
var map = mapManager.CreateNewMapEntity(MapId.Nullspace); var map = mapManager.CreateNewMapEntity(MapId.Nullspace);
grid = mapManager.CreateGrid(MapId.Nullspace); grid = mapManager.CreateGrid(MapId.Nullspace);
@@ -255,7 +229,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
//CollectionAssert.AreNotEqual(deviceNetTestSystem.LastPayload, payload); //CollectionAssert.AreNotEqual(deviceNetTestSystem.LastPayload, payload);
entityManager.SpawnEntity("CableApcExtension", grid.MapToGrid(new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 1), MapId.Nullspace))); entityManager.SpawnEntity("CableApcExtension", grid.MapToGrid(new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 1), MapId.Nullspace)));
@@ -266,11 +240,11 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => { await server.WaitAssertion(() => {
CollectionAssert.AreEqual(deviceNetTestSystem.LastPayload, payload); CollectionAssert.AreEqual(deviceNetTestSystem.LastPayload, payload);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

10
Content.IntegrationTests/Tests/Disposal/DisposalUnitTest.cs
View File

@@ -18,7 +18,7 @@ namespace Content.IntegrationTests.Tests.Disposal
[TestOf(typeof(DisposalHolderComponent))] [TestOf(typeof(DisposalHolderComponent))]
[TestOf(typeof(DisposalEntryComponent))] [TestOf(typeof(DisposalEntryComponent))]
[TestOf(typeof(DisposalUnitComponent))] [TestOf(typeof(DisposalUnitComponent))]
public sealed class DisposalUnitTest : ContentIntegrationTest public sealed class DisposalUnitTest
{ {
[Reflect(false)] [Reflect(false)]
private sealed class DisposalUnitTestSystem : EntitySystem private sealed class DisposalUnitTestSystem : EntitySystem
@@ -127,9 +127,8 @@ namespace Content.IntegrationTests.Tests.Disposal
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var options = new ServerIntegrationOptions { ExtraPrototypes = Prototypes }; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
EntityUid human = default!; EntityUid human = default!;
EntityUid wrench = default!; EntityUid wrench = default!;
@@ -143,7 +142,7 @@ namespace Content.IntegrationTests.Tests.Disposal
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
// Spawn the entities // Spawn the entities
var coordinates = GetMainEntityCoordinates(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
human = entityManager.SpawnEntity("HumanDummy", coordinates); human = entityManager.SpawnEntity("HumanDummy", coordinates);
wrench = entityManager.SpawnEntity("WrenchDummy", coordinates); wrench = entityManager.SpawnEntity("WrenchDummy", coordinates);
disposalUnit = entityManager.SpawnEntity("DisposalUnitDummy", coordinates); disposalUnit = entityManager.SpawnEntity("DisposalUnitDummy", coordinates);
@@ -208,6 +207,7 @@ namespace Content.IntegrationTests.Tests.Disposal
// Re-pressurizing // Re-pressurizing
Flush(unit, false); Flush(unit, false);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

19
Content.IntegrationTests/Tests/DoAfter/DoAfterServerTest.cs
View File

@@ -11,7 +11,7 @@ namespace Content.IntegrationTests.Tests.DoAfter
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(DoAfterComponent))] [TestOf(typeof(DoAfterComponent))]
public sealed class DoAfterServerTest : ContentIntegrationTest public sealed class DoAfterServerTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -25,11 +25,11 @@ namespace Content.IntegrationTests.Tests.DoAfter
public async Task TestFinished() public async Task TestFinished()
{ {
Task<DoAfterStatus> task = null; Task<DoAfterStatus> task = null;
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
// That it finishes successfully // That it finishes successfully
server.Post(() => await server.WaitPost(() =>
{ {
var tickTime = 1.0f / IoCManager.Resolve<IGameTiming>().TickRate; var tickTime = 1.0f / IoCManager.Resolve<IGameTiming>().TickRate;
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
@@ -43,16 +43,19 @@ namespace Content.IntegrationTests.Tests.DoAfter
await server.WaitRunTicks(1); await server.WaitRunTicks(1);
Assert.That(task.Result == DoAfterStatus.Finished); Assert.That(task.Result == DoAfterStatus.Finished);
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestCancelled() public async Task TestCancelled()
{ {
Task<DoAfterStatus> task = null; Task<DoAfterStatus> task = null;
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes};
var server = StartServer(options);
server.Post(() => await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
await server.WaitPost(() =>
{ {
var tickTime = 1.0f / IoCManager.Resolve<IGameTiming>().TickRate; var tickTime = 1.0f / IoCManager.Resolve<IGameTiming>().TickRate;
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
@@ -67,6 +70,8 @@ namespace Content.IntegrationTests.Tests.DoAfter
await server.WaitRunTicks(3); await server.WaitRunTicks(3);
Assert.That(task.Result == DoAfterStatus.Cancelled, $"Result was {task.Result}"); Assert.That(task.Result == DoAfterStatus.Cancelled, $"Result was {task.Result}");
await pairTracker.CleanReturnAsync();
} }
} }
} }

34
Content.IntegrationTests/Tests/Doors/AirlockTest.cs
View File

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests.Doors
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(AirlockComponent))] [TestOf(typeof(AirlockComponent))]
public sealed class AirlockTest : ContentIntegrationTest public sealed class AirlockTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -48,10 +48,8 @@ namespace Content.IntegrationTests.Tests.Doors
[Test] [Test]
public async Task OpenCloseDestroyTest() public async Task OpenCloseDestroyTest()
{ {
var options = new ServerIntegrationOptions {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -59,7 +57,7 @@ namespace Content.IntegrationTests.Tests.Doors
EntityUid airlock = default; EntityUid airlock = default;
DoorComponent doorComponent = null; DoorComponent doorComponent = null;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapManager.CreateNewMapEntity(MapId.Nullspace); mapManager.CreateNewMapEntity(MapId.Nullspace);
@@ -71,7 +69,7 @@ namespace Content.IntegrationTests.Tests.Doors
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Assert(() => await server.WaitAssertion(() =>
{ {
EntitySystem.Get<DoorSystem>().StartOpening(airlock); EntitySystem.Get<DoorSystem>().StartOpening(airlock);
Assert.That(doorComponent.State, Is.EqualTo(DoorState.Opening)); Assert.That(doorComponent.State, Is.EqualTo(DoorState.Opening));
@@ -79,21 +77,21 @@ namespace Content.IntegrationTests.Tests.Doors
await server.WaitIdleAsync(); await server.WaitIdleAsync();
await WaitUntil(server, () => doorComponent.State == DoorState.Open); await PoolManager.WaitUntil(server, () => doorComponent.State == DoorState.Open);
Assert.That(doorComponent.State, Is.EqualTo(DoorState.Open)); Assert.That(doorComponent.State, Is.EqualTo(DoorState.Open));
server.Assert(() => await server.WaitAssertion(() =>
{ {
EntitySystem.Get<DoorSystem>().TryClose((EntityUid) airlock); EntitySystem.Get<DoorSystem>().TryClose((EntityUid) airlock);
Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closing)); Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closing));
}); });
await WaitUntil(server, () => doorComponent.State == DoorState.Closed); await PoolManager.WaitUntil(server, () => doorComponent.State == DoorState.Closed);
Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closed)); Assert.That(doorComponent.State, Is.EqualTo(DoorState.Closed));
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.DoesNotThrow(() => Assert.DoesNotThrow(() =>
{ {
@@ -103,17 +101,14 @@ namespace Content.IntegrationTests.Tests.Doors
server.RunTicks(5); server.RunTicks(5);
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task AirlockBlockTest() public async Task AirlockBlockTest()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = Prototypes
};
var server = StartServer(options);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
@@ -127,7 +122,7 @@ namespace Content.IntegrationTests.Tests.Doors
var physicsDummyStartingX = -1; var physicsDummyStartingX = -1;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
@@ -151,7 +146,7 @@ namespace Content.IntegrationTests.Tests.Doors
for (var i = 0; i < 240; i += 10) for (var i = 0; i < 240; i += 10)
{ {
// Keep the airlock awake so they collide // Keep the airlock awake so they collide
server.Post(() => entityManager.GetComponent<IPhysBody>(airlock).WakeBody()); await server.WaitPost(() => entityManager.GetComponent<IPhysBody>(airlock).WakeBody());
await server.WaitRunTicks(10); await server.WaitRunTicks(10);
await server.WaitIdleAsync(); await server.WaitIdleAsync();
@@ -165,6 +160,7 @@ namespace Content.IntegrationTests.Tests.Doors
// Blocked by the airlock // Blocked by the airlock
await server.WaitAssertion(() => Assert.That(Math.Abs(entityManager.GetComponent<TransformComponent>(physicsDummy).MapPosition.X - 1) > 0.01f)); await server.WaitAssertion(() => Assert.That(Math.Abs(entityManager.GetComponent<TransformComponent>(physicsDummy).MapPosition.X - 1) > 0.01f));
await pairTracker.CleanReturnAsync();
} }
} }
} }

9
Content.IntegrationTests/Tests/DummyIconTest.cs
View File

@@ -9,16 +9,17 @@ using Robust.Shared.Prototypes;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class DummyIconTest : ContentIntegrationTest public sealed class DummyIconTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var (client, _) = await StartConnectedServerClientPair(new ClientContentIntegrationOption(){ Pool = false }, new ServerContentIntegrationOption() { Pool = false }); await using var pairTracker = await PoolManager.GetServerClient();
var client = pairTracker.Pair.Client;
var prototypeManager = client.ResolveDependency<IPrototypeManager>(); var prototypeManager = client.ResolveDependency<IPrototypeManager>();
var resourceCache = client.ResolveDependency<IResourceCache>(); var resourceCache = client.ResolveDependency<IResourceCache>();
await client.WaitRunTicks(5);
await client.WaitAssertion(() => await client.WaitAssertion(() =>
{ {
foreach (var proto in prototypeManager.EnumeratePrototypes<EntityPrototype>()) foreach (var proto in prototypeManager.EnumeratePrototypes<EntityPrototype>())
@@ -32,6 +33,8 @@ namespace Content.IntegrationTests.Tests
proto.ID); proto.ID);
} }
}); });
await client.WaitRunTicks(5);
await pairTracker.CleanReturnAsync();
} }
} }
} }

57
Content.IntegrationTests/Tests/EntityTest.cs
View File

@@ -15,18 +15,13 @@ namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(EntityUid))] [TestOf(typeof(EntityUid))]
public sealed class EntityTest : ContentIntegrationTest public sealed class EntityTest
{ {
[Test] [Test]
public async Task SpawnTest() public async Task SpawnTest()
{ {
var options = new ServerContentIntegrationOption() await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, Dirty = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides = {{CCVars.NPCMaxUpdates.Name, int.MaxValue.ToString()}}
};
var server = StartServer(options);
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityMan = server.ResolveDependency<IEntityManager>(); var entityMan = server.ResolveDependency<IEntityManager>();
@@ -38,7 +33,7 @@ namespace Content.IntegrationTests.Tests
EntityUid testEntity; EntityUid testEntity;
//Build up test environment //Build up test environment
server.Post(() => await server.WaitPost(() =>
{ {
// Create a one tile grid to stave off the grid 0 monsters // Create a one tile grid to stave off the grid 0 monsters
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
@@ -56,7 +51,9 @@ namespace Content.IntegrationTests.Tests
mapManager.DoMapInitialize(mapId); mapManager.DoMapInitialize(mapId);
}); });
server.Assert(() => await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{ {
var testLocation = grid.ToCoordinates(); var testLocation = grid.ToCoordinates();
@@ -80,7 +77,7 @@ namespace Content.IntegrationTests.Tests
{ {
Logger.LogS(LogLevel.Debug, "EntityTest", $"Testing: {prototype.ID}"); Logger.LogS(LogLevel.Debug, "EntityTest", $"Testing: {prototype.ID}");
testEntity = entityMan.SpawnEntity(prototype.ID, testLocation); testEntity = entityMan.SpawnEntity(prototype.ID, testLocation);
server.RunTicks(2); server.RunTicks(1);
if(!entityMan.Deleted(testEntity)) if(!entityMan.Deleted(testEntity))
entityMan.DeleteEntity(testEntity); entityMan.DeleteEntity(testEntity);
}, "Entity '{0}' threw an exception.", }, "Entity '{0}' threw an exception.",
@@ -89,7 +86,7 @@ namespace Content.IntegrationTests.Tests
}); });
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
@@ -110,12 +107,8 @@ namespace Content.IntegrationTests.Tests
- type: entity - type: entity
id: AllComponentsOneToOneDeleteTestEntity"; id: AllComponentsOneToOneDeleteTestEntity";
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = testEntity});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = testEntity,
FailureLogLevel = LogLevel.Error
});
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -124,7 +117,7 @@ namespace Content.IntegrationTests.Tests
IMapGrid grid = default; IMapGrid grid = default;
server.Post(() => await server.WaitPost(() =>
{ {
// Create a one tile grid to stave off the grid 0 monsters // Create a one tile grid to stave off the grid 0 monsters
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
@@ -142,7 +135,9 @@ namespace Content.IntegrationTests.Tests
mapManager.DoMapInitialize(mapId); mapManager.DoMapInitialize(mapId);
}); });
server.Assert(() => await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{ {
Assert.Multiple(() => Assert.Multiple(() =>
{ {
@@ -179,14 +174,12 @@ namespace Content.IntegrationTests.Tests
}, "Component '{0}' threw an exception.", }, "Component '{0}' threw an exception.",
component.Name); component.Name);
server.RunTicks(2);
entityManager.DeleteEntity(entity); entityManager.DeleteEntity(entity);
} }
}); });
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
@@ -207,13 +200,8 @@ namespace Content.IntegrationTests.Tests
- type: entity - type: entity
id: AllComponentsOneEntityDeleteTestEntity"; id: AllComponentsOneEntityDeleteTestEntity";
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = testEntity});
{ var server = pairTracker.Pair.Server;
ExtraPrototypes = testEntity,
FailureLogLevel = LogLevel.Error,
Pool = false
});
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -222,7 +210,7 @@ namespace Content.IntegrationTests.Tests
IMapGrid grid = default; IMapGrid grid = default;
server.Post(() => await server.WaitPost(() =>
{ {
// Create a one tile grid to stave off the grid 0 monsters // Create a one tile grid to stave off the grid 0 monsters
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
@@ -237,6 +225,7 @@ namespace Content.IntegrationTests.Tests
grid.SetTile(Vector2i.Zero, tile); grid.SetTile(Vector2i.Zero, tile);
mapManager.DoMapInitialize(mapId); mapManager.DoMapInitialize(mapId);
}); });
await server.WaitRunTicks(5);
var distinctComponents = new List<(List<CompIdx> components, List<CompIdx> references)> var distinctComponents = new List<(List<CompIdx> components, List<CompIdx> references)>
{ {
@@ -272,7 +261,7 @@ namespace Content.IntegrationTests.Tests
// Sanity check // Sanity check
Assert.That(distinctComponents, Is.Not.Empty); Assert.That(distinctComponents, Is.Not.Empty);
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.Multiple(() => Assert.Multiple(() =>
{ {
@@ -313,14 +302,12 @@ namespace Content.IntegrationTests.Tests
}, "Component '{0}' threw an exception.", }, "Component '{0}' threw an exception.",
component.Name); component.Name);
} }
server.RunTicks(2);
entityManager.DeleteEntity(entity); entityManager.DeleteEntity(entity);
} }
}); });
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

22
Content.IntegrationTests/Tests/Fluids/FluidSpillTest.cs
View File

@@ -15,7 +15,7 @@ namespace Content.IntegrationTests.Tests.Fluids;
[TestFixture] [TestFixture]
[TestOf(typeof(FluidSpreaderSystem))] [TestOf(typeof(FluidSpreaderSystem))]
public sealed class FluidSpill : ContentIntegrationTest public sealed class FluidSpill
{ {
private static PuddleComponent? GetPuddle(IEntityManager entityManager, IMapGrid mapGrid, Vector2i pos) private static PuddleComponent? GetPuddle(IEntityManager entityManager, IMapGrid mapGrid, Vector2i pos)
{ {
@@ -46,9 +46,8 @@ public sealed class FluidSpill : ContentIntegrationTest
[Test] [Test]
public async Task SpillEvenlyTest() public async Task SpillEvenlyTest()
{ {
// --- Setup await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = StartServer(); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -85,7 +84,7 @@ public sealed class FluidSpill : ContentIntegrationTest
var sTimeToWait = (int) Math.Ceiling(2f * gameTiming.TickRate); var sTimeToWait = (int) Math.Ceiling(2f * gameTiming.TickRate);
await server.WaitRunTicks(sTimeToWait); await server.WaitRunTicks(sTimeToWait);
server.Assert(() => await server.WaitAssertion(() =>
{ {
var grid = mapManager.GetGrid(gridId); var grid = mapManager.GetGrid(gridId);
var puddle = GetPuddle(entityManager, grid, _origin); var puddle = GetPuddle(entityManager, grid, _origin);
@@ -102,16 +101,15 @@ public sealed class FluidSpill : ContentIntegrationTest
} }
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task SpillSmallOverflowTest() public async Task SpillSmallOverflowTest()
{ {
// --- Setup await using var pairTracker = await PoolManager.GetServerClient();
var server = StartServer(); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -147,9 +145,9 @@ public sealed class FluidSpill : ContentIntegrationTest
}); });
var sTimeToWait = (int) Math.Ceiling(2f * gameTiming.TickRate); var sTimeToWait = (int) Math.Ceiling(2f * gameTiming.TickRate);
await server.WaitRunTicks(sTimeToWait); await PoolManager.RunTicksSync(pairTracker.Pair, sTimeToWait);
server.Assert(() => await server.WaitAssertion(() =>
{ {
var grid = mapManager.GetGrid(gridId); var grid = mapManager.GetGrid(gridId);
var puddle = GetPuddle(entityManager, grid, _origin); var puddle = GetPuddle(entityManager, grid, _origin);
@@ -178,6 +176,6 @@ public sealed class FluidSpill : ContentIntegrationTest
Assert.That(fullField, Is.EqualTo(1)); Assert.That(fullField, Is.EqualTo(1));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }

46
Content.IntegrationTests/Tests/Fluids/PuddleTest.cs
View File

@@ -14,39 +14,39 @@ namespace Content.IntegrationTests.Tests.Fluids
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(PuddleComponent))] [TestOf(typeof(PuddleComponent))]
public sealed class PuddleTest : ContentIntegrationTest public sealed class PuddleTest
{ {
[Test] [Test]
public async Task TilePuddleTest() public async Task TilePuddleTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>(); var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var spillSystem = entitySystemManager.GetEntitySystem<SpillableSystem>(); var spillSystem = entitySystemManager.GetEntitySystem<SpillableSystem>();
server.Assert(() => await server.WaitAssertion(() =>
{ {
var solution = new Solution("Water", FixedPoint2.New(20)); var solution = new Solution("Water", FixedPoint2.New(20));
var grid = GetMainGrid(mapManager); var tile = PoolManager.GetMainTile(mapManager);
var (x, y) = GetMainTile(grid).GridIndices; var gridUid = tile.GridUid;
var coordinates = new EntityCoordinates(grid.GridEntityId, x, y); var (x, y) = tile.GridIndices;
var coordinates = new EntityCoordinates(gridUid, x, y);
var puddle = spillSystem.SpillAt(solution, coordinates, "PuddleSmear"); var puddle = spillSystem.SpillAt(solution, coordinates, "PuddleSmear");
Assert.NotNull(puddle); Assert.NotNull(puddle);
}); });
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task SpaceNoPuddleTest() public async Task SpaceNoPuddleTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>(); var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
@@ -55,9 +55,9 @@ namespace Content.IntegrationTests.Tests.Fluids
IMapGrid grid = null; IMapGrid grid = null;
// Remove all tiles // Remove all tiles
server.Post(() => await server.WaitPost(() =>
{ {
grid = GetMainGrid(mapManager); grid = PoolManager.GetMainGrid(mapManager);
foreach (var tile in grid.GetAllTiles()) foreach (var tile in grid.GetAllTiles())
{ {
@@ -65,9 +65,9 @@ namespace Content.IntegrationTests.Tests.Fluids
} }
}); });
await server.WaitIdleAsync(); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.Assert(() => await server.WaitAssertion(() =>
{ {
var coordinates = grid.ToCoordinates(); var coordinates = grid.ToCoordinates();
var solution = new Solution("Water", FixedPoint2.New(20)); var solution = new Solution("Water", FixedPoint2.New(20));
@@ -75,15 +75,14 @@ namespace Content.IntegrationTests.Tests.Fluids
Assert.Null(puddle); Assert.Null(puddle);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task PuddlePauseTest() public async Task PuddlePauseTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
var sTileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>(); var sTileDefinitionManager = server.ResolveDependency<ITileDefinitionManager>();
@@ -154,8 +153,8 @@ namespace Content.IntegrationTests.Tests.Fluids
}); });
// Wait enough time for it to evaporate if it was unpaused // Wait enough time for it to evaporate if it was unpaused
var sTimeToWait = (5 + (int)Math.Ceiling(amount * evaporateTime * sGameTiming.TickRate)); var sTimeToWait = 5 + (int)Math.Ceiling(amount * evaporateTime * sGameTiming.TickRate);
await server.WaitRunTicks(sTimeToWait); await PoolManager.RunTicksSync(pairTracker.Pair, sTimeToWait);
// No evaporation due to being paused // No evaporation due to being paused
await server.WaitAssertion(() => await server.WaitAssertion(() =>
@@ -181,7 +180,7 @@ namespace Content.IntegrationTests.Tests.Fluids
}); });
// Wait enough time for it to evaporate // Wait enough time for it to evaporate
await server.WaitRunTicks(sTimeToWait); await PoolManager.RunTicksSync(pairTracker.Pair, sTimeToWait);
// Puddle evaporation should have ticked // Puddle evaporation should have ticked
await server.WaitAssertion(() => await server.WaitAssertion(() =>
@@ -189,6 +188,7 @@ namespace Content.IntegrationTests.Tests.Fluids
// Check that puddle has been deleted // Check that puddle has been deleted
Assert.True(puddle.Deleted); Assert.True(puddle.Deleted);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

8
Content.IntegrationTests/Tests/FollowerSystemTest.cs
View File

@@ -1,3 +1,4 @@
using System;
using System.Linq; using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Content.Shared.Follower; using Content.Shared.Follower;
@@ -10,7 +11,7 @@ using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests; namespace Content.IntegrationTests.Tests;
[TestFixture, TestOf(typeof(FollowerSystem))] [TestFixture, TestOf(typeof(FollowerSystem))]
public sealed class FollowerSystemTest : ContentIntegrationTest public sealed class FollowerSystemTest
{ {
/// <summary> /// <summary>
/// This test ensures that deleting a map while an entity follows another doesn't throw any exceptions. /// This test ensures that deleting a map while an entity follows another doesn't throw any exceptions.
@@ -18,8 +19,8 @@ public sealed class FollowerSystemTest : ContentIntegrationTest
[Test] [Test]
public async Task FollowerMapDeleteTest() public async Task FollowerMapDeleteTest()
{ {
var server = StartServerDummyTicker(); await using var pairTracker = await PoolManager.GetServerClient(new (){NoClient = true});
await server.WaitIdleAsync(); var server = pairTracker.Pair.Server;
await server.WaitPost(() => await server.WaitPost(() =>
{ {
@@ -59,5 +60,6 @@ public sealed class FollowerSystemTest : ContentIntegrationTest
entMan.DeleteEntity(ent); entMan.DeleteEntity(ent);
} }
}); });
await pairTracker.CleanReturnAsync();
} }
} }

10
Content.IntegrationTests/Tests/GameObjects/Components/ActionBlocking/HandCuffTest.cs
View File

@@ -16,7 +16,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
[TestFixture] [TestFixture]
[TestOf(typeof(CuffableComponent))] [TestOf(typeof(CuffableComponent))]
[TestOf(typeof(HandcuffComponent))] [TestOf(typeof(HandcuffComponent))]
public sealed class HandCuffTest : ContentIntegrationTest public sealed class HandCuffTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -39,8 +39,8 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
EntityUid human; EntityUid human;
EntityUid otherHuman; EntityUid otherHuman;
@@ -49,7 +49,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
CuffableComponent cuffed; CuffableComponent cuffed;
HandsComponent hands; HandsComponent hands;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
@@ -89,7 +89,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.ActionBlocking
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
private void AddHand(EntityUid to) private void AddHand(EntityUid to)

14
Content.IntegrationTests/Tests/GameObjects/Components/EntityPrototypeComponentsTest.cs
View File

@@ -13,14 +13,14 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(Server.Entry.IgnoredComponents))] [TestOf(typeof(Server.Entry.IgnoredComponents))]
public sealed class EntityPrototypeComponentsTest : ContentIntegrationTest public sealed class EntityPrototypeComponentsTest
{ {
[Test] [Test]
public async Task PrototypesHaveKnownComponents() public async Task PrototypesHaveKnownComponents()
{ {
var (client, server) = await StartConnectedServerDummyTickerClientPair(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync(); var client = pairTracker.Pair.Client;
var sResourceManager = server.ResolveDependency<IResourceManager>(); var sResourceManager = server.ResolveDependency<IResourceManager>();
var prototypePath = new ResourcePath("/Prototypes/"); var prototypePath = new ResourcePath("/Prototypes/");
@@ -95,6 +95,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components
if (unknownComponentsClient.Count + unknownComponentsServer.Count == 0) if (unknownComponentsClient.Count + unknownComponentsServer.Count == 0)
{ {
await pairTracker.CleanReturnAsync();
Assert.Pass($"Validated {entitiesValidated} entities with {componentsValidated} components in {paths.Length} files."); Assert.Pass($"Validated {entitiesValidated} entities with {componentsValidated} components in {paths.Length} files.");
return; return;
} }
@@ -119,7 +120,9 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components
[Test] [Test]
public async Task IgnoredComponentsExistInTheCorrectPlaces() public async Task IgnoredComponentsExistInTheCorrectPlaces()
{ {
var (client, server) = await StartConnectedServerClientPair(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var client = pairTracker.Pair.Client;
var serverComponents = server.ResolveDependency<IComponentFactory>(); var serverComponents = server.ResolveDependency<IComponentFactory>();
var ignoredServerNames = Server.Entry.IgnoredComponents.List; var ignoredServerNames = Server.Entry.IgnoredComponents.List;
var clientComponents = client.ResolveDependency<IComponentFactory>(); var clientComponents = client.ResolveDependency<IComponentFactory>();
@@ -137,6 +140,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components
} }
} }
Assert.IsEmpty(failureMessages); Assert.IsEmpty(failureMessages);
await pairTracker.CleanReturnAsync();
} }
} }
} }

15
Content.IntegrationTests/Tests/GameObjects/Components/Mobs/AlertsComponentTests.cs
View File

@@ -12,15 +12,14 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Mobs
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(AlertsComponent))] [TestOf(typeof(AlertsComponent))]
public sealed class AlertsComponentTests : ContentIntegrationTest public sealed class AlertsComponentTests
{ {
[Test] [Test]
public async Task AlertsTest() public async Task AlertsTest()
{ {
var (client, server) = await StartConnectedServerClientPair(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync(); var client = pairTracker.Pair.Client;
await client.WaitIdleAsync();
var serverPlayerManager = server.ResolveDependency<IPlayerManager>(); var serverPlayerManager = server.ResolveDependency<IPlayerManager>();
var alertsSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<AlertsSystem>(); var alertsSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<AlertsSystem>();
@@ -39,7 +38,6 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Mobs
await server.WaitRunTicks(5); await server.WaitRunTicks(5);
await client.WaitRunTicks(5); await client.WaitRunTicks(5);
var clientPlayerMgr = client.ResolveDependency<Robust.Client.Player.IPlayerManager>(); var clientPlayerMgr = client.ResolveDependency<Robust.Client.Player.IPlayerManager>();
var clientUIMgr = client.ResolveDependency<IUserInterfaceManager>(); var clientUIMgr = client.ResolveDependency<IUserInterfaceManager>();
await client.WaitAssertion(() => await client.WaitAssertion(() =>
@@ -74,8 +72,8 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Mobs
alertsSystem.ClearAlert(alertsComponent.Owner, AlertType.Debug1); alertsSystem.ClearAlert(alertsComponent.Owner, AlertType.Debug1);
}); });
await server.WaitRunTicks(5);
await client.WaitRunTicks(5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await client.WaitAssertion(() => await client.WaitAssertion(() =>
{ {
@@ -99,6 +97,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Mobs
var expectedIDs = new [] {AlertType.HumanHealth, AlertType.Debug2}; var expectedIDs = new [] {AlertType.HumanHealth, AlertType.Debug2};
Assert.That(alertIDs, Is.SupersetOf(expectedIDs)); Assert.That(alertIDs, Is.SupersetOf(expectedIDs));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

12
Content.IntegrationTests/Tests/GameObjects/Components/Movement/ClimbUnitTest.cs
View File

@@ -6,15 +6,13 @@ using NUnit.Framework;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.IoC; using Robust.Shared.IoC;
using Robust.Shared.Map; using Robust.Shared.Map;
using Robust.Shared.Physics;
using Content.Server.Climbing;
namespace Content.IntegrationTests.Tests.GameObjects.Components.Movement namespace Content.IntegrationTests.Tests.GameObjects.Components.Movement
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(ClimbableComponent))] [TestOf(typeof(ClimbableComponent))]
[TestOf(typeof(ClimbingComponent))] [TestOf(typeof(ClimbingComponent))]
public sealed class ClimbUnitTest : ContentIntegrationTest public sealed class ClimbUnitTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -35,14 +33,14 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Movement
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
EntityUid human; EntityUid human;
EntityUid table; EntityUid table;
ClimbingComponent climbing; ClimbingComponent climbing;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var mapManager = IoCManager.Resolve<IMapManager>(); var mapManager = IoCManager.Resolve<IMapManager>();
mapManager.CreateNewMapEntity(MapId.Nullspace); mapManager.CreateNewMapEntity(MapId.Nullspace);
@@ -69,7 +67,7 @@ namespace Content.IntegrationTests.Tests.GameObjects.Components.Movement
// climbing.IsClimbing = false; // climbing.IsClimbing = false;
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

40
Content.IntegrationTests/Tests/GameRules/RuleMaxTimeRestartTest.cs
View File

@@ -1,8 +1,11 @@
using System; using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using Content.Server.GameTicking; using Content.Server.GameTicking;
using Content.Server.GameTicking.Commands;
using Content.Server.GameTicking.Rules; using Content.Server.GameTicking.Rules;
using Content.Shared.CCVar;
using NUnit.Framework; using NUnit.Framework;
using Robust.Shared.Configuration;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.IoC; using Robust.Shared.IoC;
using Robust.Shared.Prototypes; using Robust.Shared.Prototypes;
@@ -12,23 +15,22 @@ namespace Content.IntegrationTests.Tests.GameRules
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(MaxTimeRestartRuleSystem))] [TestOf(typeof(MaxTimeRestartRuleSystem))]
public sealed class RuleMaxTimeRestartTest : ContentIntegrationTest public sealed class RuleMaxTimeRestartTest
{ {
[Test] [Test]
public async Task RestartTest() public async Task RestartTest()
{ {
var options = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient();
{ var server = pairTracker.Pair.Server;
CVarOverrides =
{ var configManager = server.ResolveDependency<IConfigurationManager>();
["game.lobbyenabled"] = "true", await server.WaitPost(() =>
["game.dummyticker"] = "false", {
["game.defaultpreset"] = "", // No preset. configManager.SetCVar(CCVars.GameLobbyEnabled, true);
} var command = new RestartRoundNowCommand();
}; command.Execute(null, string.Empty, Array.Empty<string>());
var server = StartServer(options); });
await server.WaitIdleAsync();
var sGameTicker = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<GameTicker>(); var sGameTicker = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<GameTicker>();
var maxTimeMaxTimeRestartRuleSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MaxTimeRestartRuleSystem>(); var maxTimeMaxTimeRestartRuleSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MaxTimeRestartRuleSystem>();
@@ -50,7 +52,7 @@ namespace Content.IntegrationTests.Tests.GameRules
}); });
var ticks = sGameTiming.TickRate * (int) Math.Ceiling(maxTimeMaxTimeRestartRuleSystem.RoundMaxTime.TotalSeconds * 1.1f); var ticks = sGameTiming.TickRate * (int) Math.Ceiling(maxTimeMaxTimeRestartRuleSystem.RoundMaxTime.TotalSeconds * 1.1f);
await server.WaitRunTicks(ticks); await PoolManager.RunTicksSync(pairTracker.Pair, ticks);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -58,12 +60,22 @@ namespace Content.IntegrationTests.Tests.GameRules
}); });
ticks = sGameTiming.TickRate * (int) Math.Ceiling(maxTimeMaxTimeRestartRuleSystem.RoundEndDelay.TotalSeconds * 1.1f); ticks = sGameTiming.TickRate * (int) Math.Ceiling(maxTimeMaxTimeRestartRuleSystem.RoundEndDelay.TotalSeconds * 1.1f);
await server.WaitRunTicks(ticks); await PoolManager.RunTicksSync(pairTracker.Pair, ticks);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
Assert.That(sGameTicker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby)); Assert.That(sGameTicker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
}); });
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await server.WaitPost(() =>
{
configManager.SetCVar(CCVars.GameLobbyEnabled, false);
var command = new RestartRoundNowCommand();
command.Execute(null, string.Empty, Array.Empty<string>());
});
await PoolManager.RunTicksSync(pairTracker.Pair, 30);
await pairTracker.CleanReturnAsync();
} }
} }
} }

37
Content.IntegrationTests/Tests/Gravity/WeightlessStatusTests.cs
View File

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests.Gravity
[TestFixture] [TestFixture]
[TestOf(typeof(WeightlessSystem))] [TestOf(typeof(WeightlessSystem))]
[TestOf(typeof(GravityGeneratorComponent))] [TestOf(typeof(GravityGeneratorComponent))]
public sealed class WeightlessStatusTests : ContentIntegrationTest public sealed class WeightlessStatusTests
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -34,10 +34,8 @@ namespace Content.IntegrationTests.Tests.Gravity
[Test] [Test]
public async Task WeightlessStatusTest() public async Task WeightlessStatusTest()
{ {
var options = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>(); var entityManager = server.ResolveDependency<IEntityManager>();
@@ -47,45 +45,44 @@ namespace Content.IntegrationTests.Tests.Gravity
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var grid = GetMainGrid(mapManager); var coordinates = PoolManager.GetMainEntityCoordinates(mapManager);
var coordinates = grid.ToCoordinates();
human = entityManager.SpawnEntity("HumanDummy", coordinates); human = entityManager.SpawnEntity("HumanDummy", coordinates);
Assert.True(entityManager.TryGetComponent(human, out AlertsComponent alerts)); Assert.True(entityManager.TryGetComponent(human, out AlertsComponent alerts));
}); });
// Let WeightlessSystem and GravitySystem tick // Let WeightlessSystem and GravitySystem tick
await server.WaitRunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
var generatorUid = EntityUid.Invalid;
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
// No gravity without a gravity generator // No gravity without a gravity generator
Assert.True(alertsSystem.IsShowingAlert(human, AlertType.Weightless)); Assert.True(alertsSystem.IsShowingAlert(human, AlertType.Weightless));
entityManager.SpawnEntity("GravityGeneratorDummy", entityManager.GetComponent<TransformComponent>(human).Coordinates); generatorUid = entityManager.SpawnEntity("GravityGeneratorDummy", entityManager.GetComponent<TransformComponent>(human).Coordinates);
}); });
// Let WeightlessSystem and GravitySystem tick // Let WeightlessSystem and GravitySystem tick
await server.WaitRunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
Assert.False(alertsSystem.IsShowingAlert(human, AlertType.Weightless)); Assert.False(alertsSystem.IsShowingAlert(human, AlertType.Weightless));
// TODO: Re-add gravity generator breaking when Vera is done with construction stuff. // This should kill gravity
/* entityManager.DeleteEntity(generatorUid);
// Disable the gravity generator
var args = new BreakageEventArgs {Owner = human};
// gravityGenerator.OnBreak(args);
*/
}); });
/*await server.WaitRunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
Assert.True(alerts.IsShowingAlert(AlertType.Weightless)); Assert.True(alertsSystem.IsShowingAlert(human, AlertType.Weightless));
});*/ });
await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await pairTracker.CleanReturnAsync();
} }
} }
} }

25
Content.IntegrationTests/Tests/GravityGridTest.cs
View File

@@ -14,7 +14,7 @@ namespace Content.IntegrationTests.Tests
/// making sure that gravity is applied to the correct grids. /// making sure that gravity is applied to the correct grids.
[TestFixture] [TestFixture]
[TestOf(typeof(GravityGeneratorComponent))] [TestOf(typeof(GravityGeneratorComponent))]
public sealed class GravityGridTest : ContentIntegrationTest public sealed class GravityGridTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -30,10 +30,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
EntityUid generator = default; EntityUid generator = default;
var entityMan = server.ResolveDependency<IEntityManager>(); var entityMan = server.ResolveDependency<IEntityManager>();
@@ -42,11 +40,11 @@ namespace Content.IntegrationTests.Tests
IMapGrid grid2 = null; IMapGrid grid2 = null;
// Create grids // Create grids
server.Assert(() => await server.WaitAssertion(() =>
{ {
var mapMan = IoCManager.Resolve<IMapManager>(); var mapMan = IoCManager.Resolve<IMapManager>();
var mapId = GetMainMapId(mapMan); var mapId = PoolManager.GetMainGrid(mapMan).ParentMapId;
grid1 = mapMan.CreateGrid(mapId); grid1 = mapMan.CreateGrid(mapId);
grid2 = mapMan.CreateGrid(mapId); grid2 = mapMan.CreateGrid(mapId);
@@ -57,9 +55,10 @@ namespace Content.IntegrationTests.Tests
var powerComponent = entityMan.GetComponent<ApcPowerReceiverComponent>(generator); var powerComponent = entityMan.GetComponent<ApcPowerReceiverComponent>(generator);
powerComponent.NeedsPower = false; powerComponent.NeedsPower = false;
}); });
server.RunTicks(1);
server.Assert(() => await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{ {
var generatorComponent = entityMan.GetComponent<GravityGeneratorComponent>(generator); var generatorComponent = entityMan.GetComponent<GravityGeneratorComponent>(generator);
var powerComponent = entityMan.GetComponent<ApcPowerReceiverComponent>(generator); var powerComponent = entityMan.GetComponent<ApcPowerReceiverComponent>(generator);
@@ -76,8 +75,10 @@ namespace Content.IntegrationTests.Tests
// Charge rate is ridiculously high so it finishes in one tick. // Charge rate is ridiculously high so it finishes in one tick.
powerComponent.NeedsPower = true; powerComponent.NeedsPower = true;
}); });
server.RunTicks(1);
server.Assert(() => await server.WaitRunTicks(5);
await server.WaitAssertion(() =>
{ {
var generatorComponent = entityMan.GetComponent<GravityGeneratorComponent>(generator); var generatorComponent = entityMan.GetComponent<GravityGeneratorComponent>(generator);
@@ -88,7 +89,7 @@ namespace Content.IntegrationTests.Tests
Assert.That(entityMan.GetComponent<GravityComponent>(grid2Entity).Enabled, Is.False); Assert.That(entityMan.GetComponent<GravityComponent>(grid2Entity).Enabled, Is.False);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

14
Content.IntegrationTests/Tests/HumanInventoryUniformSlotsTest.cs
View File

@@ -11,7 +11,7 @@ namespace Content.IntegrationTests.Tests
// i.e. the interaction between uniforms and the pocket/ID slots. // i.e. the interaction between uniforms and the pocket/ID slots.
// and also how big items don't fit in pockets. // and also how big items don't fit in pockets.
[TestFixture] [TestFixture]
public sealed class HumanInventoryUniformSlotsTest : ContentIntegrationTest public sealed class HumanInventoryUniformSlotsTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -56,8 +56,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var options = new ServerIntegrationOptions{ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
EntityUid human = default; EntityUid human = default;
EntityUid uniform = default; EntityUid uniform = default;
@@ -66,7 +66,7 @@ namespace Content.IntegrationTests.Tests
InventorySystem invSystem = default!; InventorySystem invSystem = default!;
server.Assert(() => await server.WaitAssertion(() =>
{ {
invSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<InventorySystem>(); invSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<InventorySystem>();
var mapMan = IoCManager.Resolve<IMapManager>(); var mapMan = IoCManager.Resolve<IMapManager>();
@@ -102,9 +102,9 @@ namespace Content.IntegrationTests.Tests
Assert.That(invSystem.TryUnequip(human, "jumpsuit")); Assert.That(invSystem.TryUnequip(human, "jumpsuit"));
}); });
server.RunTicks(2); await server.WaitRunTicks(2);
server.Assert(() => await server.WaitAssertion(() =>
{ {
// Items have been dropped! // Items have been dropped!
Assert.That(IsDescendant(uniform, human), Is.False); Assert.That(IsDescendant(uniform, human), Is.False);
@@ -117,7 +117,7 @@ namespace Content.IntegrationTests.Tests
Assert.That(!invSystem.TryGetSlotEntity(human, "pocket1", out _)); Assert.That(!invSystem.TryGetSlotEntity(human, "pocket1", out _));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
private static bool IsDescendant(EntityUid descendant, EntityUid parent) private static bool IsDescendant(EntityUid descendant, EntityUid parent)

103
Content.IntegrationTests/Tests/Interaction/Click/InteractionSystemTests.cs
View File

@@ -19,9 +19,9 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(InteractionSystem))] [TestOf(typeof(InteractionSystem))]
public sealed class InteractionSystemTests : ContentIntegrationTest public sealed class InteractionSystemTests
{ {
const string PROTOTYPES = @" private const string Prototypes = @"
- type: entity - type: entity
id: DummyDebugWall id: DummyDebugWall
components: components:
@@ -41,15 +41,8 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
[Test] [Test]
public async Task InteractionTest() public async Task InteractionTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestInteractionSystem>();
}
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -58,7 +51,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var mapId = MapId.Nullspace; var mapId = MapId.Nullspace;
var coords = MapCoordinates.Nullspace; var coords = MapCoordinates.Nullspace;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapId = mapManager.CreateMap(); mapId = mapManager.CreateMap();
coords = new MapCoordinates(Vector2.Zero, mapId); coords = new MapCoordinates(Vector2.Zero, mapId);
@@ -69,7 +62,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
EntityUid target = default; EntityUid target = default;
EntityUid item = default; EntityUid item = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
user = sEntities.SpawnEntity(null, coords); user = sEntities.SpawnEntity(null, coords);
user.EnsureComponent<HandsComponent>(); user.EnsureComponent<HandsComponent>();
@@ -88,7 +81,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var attack = false; var attack = false;
var interactUsing = false; var interactUsing = false;
var interactHand = false; var interactHand = false;
server.Assert(() => await server.WaitAssertion(() =>
{ {
testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; }; testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; };
testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; }; testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; };
@@ -106,22 +99,14 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
Assert.That(interactUsing); Assert.That(interactUsing);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task InteractionObstructionTest() public async Task InteractionObstructionTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestInteractionSystem>();
},
ExtraPrototypes = PROTOTYPES
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -130,7 +115,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var mapId = MapId.Nullspace; var mapId = MapId.Nullspace;
var coords = MapCoordinates.Nullspace; var coords = MapCoordinates.Nullspace;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapId = mapManager.CreateMap(); mapId = mapManager.CreateMap();
coords = new MapCoordinates(Vector2.Zero, mapId); coords = new MapCoordinates(Vector2.Zero, mapId);
@@ -142,7 +127,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
EntityUid item = default; EntityUid item = default;
EntityUid wall = default; EntityUid wall = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
user = sEntities.SpawnEntity(null, coords); user = sEntities.SpawnEntity(null, coords);
user.EnsureComponent<HandsComponent>(); user.EnsureComponent<HandsComponent>();
@@ -162,7 +147,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var attack = false; var attack = false;
var interactUsing = false; var interactUsing = false;
var interactHand = false; var interactHand = false;
server.Assert(() => await server.WaitAssertion(() =>
{ {
testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; }; testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; };
testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; }; testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; };
@@ -180,21 +165,14 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
Assert.That(interactUsing, Is.False); Assert.That(interactUsing, Is.False);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task InteractionInRangeTest() public async Task InteractionInRangeTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestInteractionSystem>();
}
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -203,7 +181,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var mapId = MapId.Nullspace; var mapId = MapId.Nullspace;
var coords = MapCoordinates.Nullspace; var coords = MapCoordinates.Nullspace;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapId = mapManager.CreateMap(); mapId = mapManager.CreateMap();
coords = new MapCoordinates(Vector2.Zero, mapId); coords = new MapCoordinates(Vector2.Zero, mapId);
@@ -214,7 +192,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
EntityUid target = default; EntityUid target = default;
EntityUid item = default; EntityUid item = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
user = sEntities.SpawnEntity(null, coords); user = sEntities.SpawnEntity(null, coords);
user.EnsureComponent<HandsComponent>(); user.EnsureComponent<HandsComponent>();
@@ -233,7 +211,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var attack = false; var attack = false;
var interactUsing = false; var interactUsing = false;
var interactHand = false; var interactHand = false;
server.Assert(() => await server.WaitAssertion(() =>
{ {
testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; }; testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; };
testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; }; testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; };
@@ -251,22 +229,15 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
Assert.That(interactUsing); Assert.That(interactUsing);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task InteractionOutOfRangeTest() public async Task InteractionOutOfRangeTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestInteractionSystem>();
}
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -275,7 +246,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var mapId = MapId.Nullspace; var mapId = MapId.Nullspace;
var coords = MapCoordinates.Nullspace; var coords = MapCoordinates.Nullspace;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapId = mapManager.CreateMap(); mapId = mapManager.CreateMap();
coords = new MapCoordinates(Vector2.Zero, mapId); coords = new MapCoordinates(Vector2.Zero, mapId);
@@ -286,7 +257,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
EntityUid target = default; EntityUid target = default;
EntityUid item = default; EntityUid item = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
user = sEntities.SpawnEntity(null, coords); user = sEntities.SpawnEntity(null, coords);
user.EnsureComponent<HandsComponent>(); user.EnsureComponent<HandsComponent>();
@@ -305,7 +276,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var attack = false; var attack = false;
var interactUsing = false; var interactUsing = false;
var interactHand = false; var interactHand = false;
server.Assert(() => await server.WaitAssertion(() =>
{ {
testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; }; testInteractionSystem.AttackEvent = (_, _, ev) => { Assert.That(ev.Target, Is.EqualTo(target)); attack = true; };
testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; }; testInteractionSystem.InteractUsingEvent = (ev) => { Assert.That(ev.Target, Is.EqualTo(target)); interactUsing = true; };
@@ -323,22 +294,14 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
Assert.That(interactUsing, Is.False); Assert.That(interactUsing, Is.False);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task InsideContainerInteractionBlockTest() public async Task InsideContainerInteractionBlockTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestInteractionSystem>();
},
FailureLogLevel = Robust.Shared.Log.LogLevel.Error
});
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -347,7 +310,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var mapId = MapId.Nullspace; var mapId = MapId.Nullspace;
var coords = MapCoordinates.Nullspace; var coords = MapCoordinates.Nullspace;
server.Assert(() => await server.WaitAssertion(() =>
{ {
mapId = mapManager.CreateMap(); mapId = mapManager.CreateMap();
coords = new MapCoordinates(Vector2.Zero, mapId); coords = new MapCoordinates(Vector2.Zero, mapId);
@@ -360,7 +323,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
EntityUid containerEntity = default; EntityUid containerEntity = default;
IContainer container = null; IContainer container = null;
server.Assert(() => await server.WaitAssertion(() =>
{ {
user = sEntities.SpawnEntity(null, coords); user = sEntities.SpawnEntity(null, coords);
user.EnsureComponent<HandsComponent>(); user.EnsureComponent<HandsComponent>();
@@ -383,7 +346,7 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
var attack = false; var attack = false;
var interactUsing = false; var interactUsing = false;
var interactHand = false; var interactHand = false;
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(container.Insert(user)); Assert.That(container.Insert(user));
Assert.That(sEntities.GetComponent<TransformComponent>(user).Parent.Owner, Is.EqualTo(containerEntity)); Assert.That(sEntities.GetComponent<TransformComponent>(user).Parent.Owner, Is.EqualTo(containerEntity));
@@ -413,11 +376,11 @@ namespace Content.IntegrationTests.Tests.Interaction.Click
Assert.That(interactUsing, Is.True); Assert.That(interactUsing, Is.True);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Reflect(false)] [Reflect(false)]
private sealed class TestInteractionSystem : EntitySystem public sealed class TestInteractionSystem : EntitySystem
{ {
public ComponentEventHandler<HandsComponent, ClickAttackEvent>? AttackEvent; public ComponentEventHandler<HandsComponent, ClickAttackEvent>? AttackEvent;
public EntityEventHandler<InteractUsingEvent>? InteractUsingEvent; public EntityEventHandler<InteractUsingEvent>? InteractUsingEvent;

13
Content.IntegrationTests/Tests/Interaction/InRangeUnobstructed.cs
View File

@@ -10,7 +10,7 @@ namespace Content.IntegrationTests.Tests.Interaction
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(SharedInteractionSystem))] [TestOf(typeof(SharedInteractionSystem))]
public sealed class InRangeUnobstructed : ContentIntegrationTest public sealed class InRangeUnobstructed
{ {
private const string HumanId = "MobHumanBase"; private const string HumanId = "MobHumanBase";
@@ -25,9 +25,8 @@ namespace Content.IntegrationTests.Tests.Interaction
[Test] [Test]
public async Task EntityEntityTest() public async Task EntityEntityTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -39,7 +38,7 @@ namespace Content.IntegrationTests.Tests.Interaction
EntityCoordinates entityCoordinates = default; EntityCoordinates entityCoordinates = default;
MapCoordinates mapCoordinates = default; MapCoordinates mapCoordinates = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var mapId = mapManager.CreateMap(); var mapId = mapManager.CreateMap();
var coordinates = new MapCoordinates(Vector2.Zero, mapId); var coordinates = new MapCoordinates(Vector2.Zero, mapId);
@@ -56,7 +55,7 @@ namespace Content.IntegrationTests.Tests.Interaction
var interactionSys = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<SharedInteractionSystem>(); var interactionSys = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<SharedInteractionSystem>();
server.Assert(() => await server.WaitAssertion(() =>
{ {
// Entity <-> Entity // Entity <-> Entity
Assert.True(interactionSys.InRangeUnobstructed(origin, other)); Assert.True(interactionSys.InRangeUnobstructed(origin, other));
@@ -100,7 +99,7 @@ namespace Content.IntegrationTests.Tests.Interaction
Assert.True(interactionSys.InRangeUnobstructed(mapCoordinates, origin, InteractionRangeDivided15Times3)); Assert.True(interactionSys.InRangeUnobstructed(mapCoordinates, origin, InteractionRangeDivided15Times3));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

9
Content.IntegrationTests/Tests/InventoryHelpersTest.cs
View File

@@ -10,7 +10,7 @@ using Robust.Shared.Map;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class InventoryHelpersTest : ContentIntegrationTest public sealed class InventoryHelpersTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -43,10 +43,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task SpawnItemInSlotTest() public async Task SpawnItemInSlotTest()
{ {
var options = new ServerIntegrationOptions {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
@@ -89,6 +87,7 @@ namespace Content.IntegrationTests.Tests
ID: "InventoryIDCardDummy" ID: "InventoryIDCardDummy"
}); });
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

46
Content.IntegrationTests/Tests/Lobby/CharacterCreationTest.cs
View File

@@ -1,15 +1,11 @@
using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using Content.Client.Lobby; using Content.Client.Lobby;
using Content.Client.Preferences; using Content.Client.Preferences;
using Content.Server.GameTicking;
using Content.Server.Preferences.Managers; using Content.Server.Preferences.Managers;
using Content.Shared.CCVar;
using Content.Shared.Preferences; using Content.Shared.Preferences;
using NUnit.Framework; using NUnit.Framework;
using Robust.Client.State; using Robust.Client.State;
using Robust.Shared;
using Robust.Shared.Configuration;
using Robust.Shared.GameObjects;
using Robust.Shared.Network; using Robust.Shared.Network;
namespace Content.IntegrationTests.Tests.Lobby namespace Content.IntegrationTests.Tests.Lobby
@@ -17,47 +13,26 @@ namespace Content.IntegrationTests.Tests.Lobby
[TestFixture] [TestFixture]
[TestOf(typeof(ClientPreferencesManager))] [TestOf(typeof(ClientPreferencesManager))]
[TestOf(typeof(ServerPreferencesManager))] [TestOf(typeof(ServerPreferencesManager))]
public sealed class CharacterCreationTest : ContentIntegrationTest public sealed class CharacterCreationTest
{ {
[Test] [Test]
public async Task CreateDeleteCreateTest() public async Task CreateDeleteCreateTest()
{ {
var serverOptions = new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{InLobby = true});
{ var server = pairTracker.Pair.Server;
CVarOverrides = var client = pairTracker.Pair.Client;
{
[CCVars.GameDummyTicker.Name] = "false",
[CCVars.GameLobbyEnabled.Name] = "true",
[CVars.NetPVS.Name] = "false"
}
};
var (client, server) = await StartConnectedServerClientPair(serverOptions: serverOptions);
var clientNetManager = client.ResolveDependency<IClientNetManager>(); var clientNetManager = client.ResolveDependency<IClientNetManager>();
var clientStateManager = client.ResolveDependency<IStateManager>(); var clientStateManager = client.ResolveDependency<IStateManager>();
var clientPrefManager = client.ResolveDependency<IClientPreferencesManager>(); var clientPrefManager = client.ResolveDependency<IClientPreferencesManager>();
var serverConfig = server.ResolveDependency<IConfigurationManager>();
var serverTicker = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<GameTicker>();
var serverPrefManager = server.ResolveDependency<IServerPreferencesManager>(); var serverPrefManager = server.ResolveDependency<IServerPreferencesManager>();
await server.WaitIdleAsync();
await client.WaitIdleAsync();
await server.WaitAssertion(() =>
{
serverConfig.SetCVar(CCVars.GameDummyTicker, false);
serverConfig.SetCVar(CCVars.GameLobbyEnabled, true);
serverTicker.RestartRound();
Assert.That(serverTicker.RunLevel, Is.EqualTo(GameRunLevel.PreRoundLobby));
});
// Need to run them in sync to receive the messages. // Need to run them in sync to receive the messages.
await RunTicksSync(client, server, 1); await PoolManager.RunTicksSync(pairTracker.Pair, 1);
await WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, 600); await PoolManager.WaitUntil(client, () => clientStateManager.CurrentState is LobbyState, 600);
Assert.NotNull(clientNetManager.ServerChannel); Assert.NotNull(clientNetManager.ServerChannel);
@@ -84,7 +59,7 @@ namespace Content.IntegrationTests.Tests.Lobby
Assert.That(clientCharacters[1].MemberwiseEquals(profile)); Assert.That(clientCharacters[1].MemberwiseEquals(profile));
}); });
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60); await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -102,7 +77,7 @@ namespace Content.IntegrationTests.Tests.Lobby
Assert.That(clientCharacters, Is.EqualTo(1)); Assert.That(clientCharacters, Is.EqualTo(1));
}); });
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks: 60); await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 1, maxTicks: 60);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -125,7 +100,7 @@ namespace Content.IntegrationTests.Tests.Lobby
Assert.That(clientCharacters[1].MemberwiseEquals(profile)); Assert.That(clientCharacters[1].MemberwiseEquals(profile));
}); });
await WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60); await PoolManager.WaitUntil(server, () => serverPrefManager.GetPreferences(clientNetId).Characters.Count == 2, maxTicks: 60);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -134,6 +109,7 @@ namespace Content.IntegrationTests.Tests.Lobby
Assert.That(serverCharacters.Count, Is.EqualTo(2)); Assert.That(serverCharacters.Count, Is.EqualTo(2));
Assert.That(serverCharacters[1].MemberwiseEquals(profile)); Assert.That(serverCharacters[1].MemberwiseEquals(profile));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

71
Content.IntegrationTests/Tests/MindEntityDeletionTest.cs
View File

@@ -8,32 +8,35 @@ using Robust.Server.Player;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.IoC; using Robust.Shared.IoC;
using Robust.Shared.Map; using Robust.Shared.Map;
using Robust.Shared.Maths;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
// Tests various scenarios of deleting the entity that a player's mind is connected to. // Tests various scenarios of deleting the entity that a player's mind is connected to.
[TestFixture] [TestFixture]
public sealed class MindEntityDeletionTest : ContentIntegrationTest public sealed class MindEntityDeletionTest
{ {
[Test] [Test]
public async Task TestDeleteVisiting() public async Task TestDeleteVisiting()
{ {
var (_, server) = await StartConnectedServerDummyTickerClientPair(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var entMan = server.ResolveDependency<IServerEntityManager>(); var entMan = server.ResolveDependency<IServerEntityManager>();
EntityUid playerEnt = default; EntityUid playerEnt = default;
EntityUid visitEnt = default; EntityUid visitEnt = default;
Mind mind = null; Mind mind = null;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single(); var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single();
var mapMan = IoCManager.Resolve<IMapManager>(); var mapMan = IoCManager.Resolve<IMapManager>();
mapMan.CreateNewMapEntity(MapId.Nullspace); var mapId = mapMan.GetAllMapIds().Last();
var pos = new MapCoordinates(Vector2.Zero, mapId);
playerEnt = entMan.SpawnEntity(null, MapCoordinates.Nullspace); playerEnt = entMan.SpawnEntity(null, pos);
visitEnt = entMan.SpawnEntity(null, MapCoordinates.Nullspace); visitEnt = entMan.SpawnEntity(null, pos);
mind = new Mind(player.UserId); mind = new Mind(player.UserId);
mind.ChangeOwningPlayer(player.UserId); mind.ChangeOwningPlayer(player.UserId);
@@ -44,40 +47,52 @@ namespace Content.IntegrationTests.Tests
Assert.That(player.AttachedEntity, Is.EqualTo(visitEnt)); Assert.That(player.AttachedEntity, Is.EqualTo(visitEnt));
Assert.That(mind.VisitingEntity, Is.EqualTo(visitEnt)); Assert.That(mind.VisitingEntity, Is.EqualTo(visitEnt));
}); });
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.RunTicks(1); await server.WaitAssertion(() =>
server.Assert(() =>
{ {
entMan.DeleteEntity(visitEnt); entMan.DeleteEntity(visitEnt);
if (mind == null)
{
Assert.Fail("Mind was null");
return;
}
Assert.That(mind.VisitingEntity, Is.EqualTo(default)); if (mind.VisitingEntity != null)
{
Assert.Fail("Mind VisitingEntity was not null");
return;
}
// This used to throw so make sure it doesn't. // This used to throw so make sure it doesn't.
entMan.DeleteEntity(playerEnt); entMan.DeleteEntity(playerEnt);
}); });
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestGhostOnDelete() public async Task TestGhostOnDelete()
{ {
// Has to be a non-dummy ticker so we have a proper map. // Has to be a non-dummy ticker so we have a proper map.
var (_, server) = await StartConnectedServerClientPair();
await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var entMan = server.ResolveDependency<IServerEntityManager>(); var entMan = server.ResolveDependency<IServerEntityManager>();
EntityUid playerEnt = default; EntityUid playerEnt = default;
Mind mind = null; Mind mind = null;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single(); var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single();
var mapMan = IoCManager.Resolve<IMapManager>(); var mapMan = IoCManager.Resolve<IMapManager>();
mapMan.CreateNewMapEntity(MapId.Nullspace); var mapId = mapMan.GetAllMapIds().Last();
var pos = new MapCoordinates(Vector2.Zero, mapId);
playerEnt = entMan.SpawnEntity(null, MapCoordinates.Nullspace); playerEnt = entMan.SpawnEntity(null, pos);
mind = new Mind(player.UserId); mind = new Mind(player.UserId);
mind.ChangeOwningPlayer(player.UserId); mind.ChangeOwningPlayer(player.UserId);
@@ -87,33 +102,33 @@ namespace Content.IntegrationTests.Tests
Assert.That(mind.CurrentEntity, Is.EqualTo(playerEnt)); Assert.That(mind.CurrentEntity, Is.EqualTo(playerEnt));
}); });
server.RunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.Post(() => await server.WaitPost(() =>
{ {
entMan.DeleteEntity(playerEnt); entMan.DeleteEntity(playerEnt);
}); });
server.RunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(entMan.EntityExists(mind.CurrentEntity!.Value), Is.True); Assert.That(entMan.EntityExists(mind.CurrentEntity!.Value), Is.True);
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestGhostOnDeleteMap() public async Task TestGhostOnDeleteMap()
{ {
// Has to be a non-dummy ticker so we have a proper map. await using var pairTracker = await PoolManager.GetServerClient();
var (_, server) = await StartConnectedServerClientPair(); var server = pairTracker.Pair.Server;
EntityUid playerEnt = default; EntityUid playerEnt = default;
Mind mind = null; Mind mind = null;
MapId map = default; MapId map = default;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single(); var player = IoCManager.Resolve<IPlayerManager>().ServerSessions.Single();
@@ -136,24 +151,24 @@ namespace Content.IntegrationTests.Tests
Assert.That(mind.CurrentEntity, Is.EqualTo(playerEnt)); Assert.That(mind.CurrentEntity, Is.EqualTo(playerEnt));
}); });
server.RunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.Post(() => await server.WaitPost(() =>
{ {
var mapMan = IoCManager.Resolve<IMapManager>(); var mapMan = IoCManager.Resolve<IMapManager>();
mapMan.DeleteMap(map); mapMan.DeleteMap(map);
}); });
server.RunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(IoCManager.Resolve<IEntityManager>().EntityExists(mind.CurrentEntity!.Value), Is.True); Assert.That(IoCManager.Resolve<IEntityManager>().EntityExists(mind.CurrentEntity!.Value), Is.True);
Assert.That(mind.CurrentEntity, Is.Not.EqualTo(playerEnt)); Assert.That(mind.CurrentEntity, Is.Not.EqualTo(playerEnt));
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

34
Content.IntegrationTests/Tests/Networking/ConnectTest.cs
View File

@@ -11,40 +11,14 @@ using Robust.Shared.Network;
namespace Content.IntegrationTests.Tests.Networking namespace Content.IntegrationTests.Tests.Networking
{ {
[TestFixture] [TestFixture]
public sealed class ConnectTest : ContentIntegrationTest public sealed class ConnectTest
{ {
[Test] [Test]
public async Task TestConnect() public async Task TestConnect()
{ {
var client = StartClient(); await using var pairTracker = await PoolManager.GetServerClient();
var server = StartServer(new ServerContentIntegrationOption var server = pairTracker.Pair.Server;
{ var client = pairTracker.Pair.Client;
Pool = false,
CVarOverrides =
{
{CVars.NetPVS.Name, "false"}
}
});
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
// Connect.
client.SetConnectTarget(server);
client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
// Run some ticks for the handshake to complete and such.
for (var i = 0; i < 10; i++)
{
server.RunTicks(1);
await server.WaitIdleAsync();
client.RunTicks(1);
await client.WaitIdleAsync();
}
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
// Basic checks to ensure that they're connected and data got replicated. // Basic checks to ensure that they're connected and data got replicated.

33
Content.IntegrationTests/Tests/Networking/NetworkIdsMatchTest.cs
View File

@@ -7,15 +7,14 @@ using Robust.Shared.Network;
namespace Content.IntegrationTests.Tests.Networking namespace Content.IntegrationTests.Tests.Networking
{ {
[TestFixture] [TestFixture]
sealed class NetworkIdsMatchTest : ContentIntegrationTest sealed class NetworkIdsMatchTest
{ {
[Test] [Test]
public async Task TestConnect() public async Task TestConnect()
{ {
var client = StartClient(); await using var pairTracker = await PoolManager.GetServerClient();
var server = StartServer(); var server = pairTracker.Pair.Server;
var client = pairTracker.Pair.Client;
await ConnectNetworking(client, server);
var clientCompFactory = client.ResolveDependency<IComponentFactory>(); var clientCompFactory = client.ResolveDependency<IComponentFactory>();
var serverCompFactory = server.ResolveDependency<IComponentFactory>(); var serverCompFactory = server.ResolveDependency<IComponentFactory>();
@@ -34,29 +33,7 @@ namespace Content.IntegrationTests.Tests.Networking
{ {
Assert.That(clientNetComps[netId].Name, Is.EqualTo(serverNetComps[netId].Name)); Assert.That(clientNetComps[netId].Name, Is.EqualTo(serverNetComps[netId].Name));
} }
} await pairTracker.CleanReturnAsync();
private static async Task ConnectNetworking(ClientIntegrationInstance client, ServerIntegrationInstance server)
{
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
// Connect.
client.SetConnectTarget(server);
client.Post(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
// Run some ticks for the handshake to complete and such.
for (var i = 0; i < 10; i++)
{
server.RunTicks(1);
await server.WaitIdleAsync();
client.RunTicks(1);
await client.WaitIdleAsync();
}
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
} }
} }
} }

24
Content.IntegrationTests/Tests/Networking/ReconnectTest.cs
View File

@@ -7,30 +7,19 @@ using Robust.Shared.Network;
namespace Content.IntegrationTests.Tests.Networking namespace Content.IntegrationTests.Tests.Networking
{ {
[TestFixture] [TestFixture]
public sealed class ReconnectTest : ContentIntegrationTest public sealed class ReconnectTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var client = StartClient(); await using var pairTracker = await PoolManager.GetServerClient();
var server = StartServer(); var server = pairTracker.Pair.Server;
var client = pairTracker.Pair.Client;
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
// Connect.
client.SetConnectTarget(server);
await client.WaitPost(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
// Run some ticks for the handshake to complete and such.
await RunTicksSync(client, server, 10);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
await client.WaitPost(() => IoCManager.Resolve<IClientConsoleHost>().ExecuteCommand("disconnect")); await client.WaitPost(() => IoCManager.Resolve<IClientConsoleHost>().ExecuteCommand("disconnect"));
// Run some ticks for the disconnect to complete and such. // Run some ticks for the disconnect to complete and such.
await RunTicksSync(client, server, 5); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
@@ -40,9 +29,10 @@ namespace Content.IntegrationTests.Tests.Networking
await client.WaitPost(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null)); await client.WaitPost(() => IoCManager.Resolve<IClientNetManager>().ClientConnect(null, 0, null));
// Run some ticks for the handshake to complete and such. // Run some ticks for the handshake to complete and such.
await RunTicksSync(client, server, 10); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
await pairTracker.CleanReturnAsync();
} }
} }
} }

47
Content.IntegrationTests/Tests/Networking/SimplePredictReconcileTest.cs
View File

@@ -6,8 +6,8 @@ using System.Threading.Tasks;
using NUnit.Framework; using NUnit.Framework;
using Robust.Client.GameObjects; using Robust.Client.GameObjects;
using Robust.Client.GameStates; using Robust.Client.GameStates;
using Robust.Server.GameStates;
using Robust.Server.Player; using Robust.Server.Player;
using Robust.Shared;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.GameStates; using Robust.Shared.GameStates;
using Robust.Shared.IoC; using Robust.Shared.IoC;
@@ -30,42 +30,14 @@ namespace Content.IntegrationTests.Tests.Networking
// the tick where the server *should* have, but did not, acknowledge the state change. // the tick where the server *should* have, but did not, acknowledge the state change.
// Finally, we run two events inside the prediction area to ensure reconciling does for incremental stuff. // Finally, we run two events inside the prediction area to ensure reconciling does for incremental stuff.
[TestFixture] [TestFixture]
public sealed class SimplePredictReconcileTest : ContentIntegrationTest public sealed class SimplePredictReconcileTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
// Initialize client & server with text component and system registered. await using var pairTracker = await PoolManager.GetServerClient(new (){Fresh = true, DisableInterpolate = true, DummyTicker = true});
// They can't be registered/detected automatically. var server = pairTracker.Pair.Server;
var (client, server) = await StartConnectedServerDummyTickerClientPair( var client = pairTracker.Pair.Client;
new ClientContentIntegrationOption
{
// This test is designed around specific timing values and when I wrote it interpolation was off.
// As such, I would have to update half this test to make sure it works with interpolation.
// I'm kinda lazy.
CVarOverrides =
{
{CVars.NetInterp.Name, "false"},
{CVars.NetPVS.Name, "false"}
},
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<PredictionTestEntitySystem>();
IoCManager.Resolve<IComponentFactory>().RegisterClass<PredictionTestComponent>();
}
},
new ServerContentIntegrationOption
{
CVarOverrides =
{
{CVars.NetPVS.Name, "false"}
},
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<PredictionTestEntitySystem>();
IoCManager.Resolve<IComponentFactory>().RegisterClass<PredictionTestComponent>();
}
});
// Pull in all dependencies we need. // Pull in all dependencies we need.
var sPlayerManager = server.ResolveDependency<IPlayerManager>(); var sPlayerManager = server.ResolveDependency<IPlayerManager>();
@@ -85,7 +57,7 @@ namespace Content.IntegrationTests.Tests.Networking
var clientSystem = client.ResolveDependency<IEntitySystemManager>() var clientSystem = client.ResolveDependency<IEntitySystemManager>()
.GetEntitySystem<PredictionTestEntitySystem>(); .GetEntitySystem<PredictionTestEntitySystem>();
server.Post(() => await server.WaitPost(() =>
{ {
// Spawn dummy component entity. // Spawn dummy component entity.
var map = sMapManager.CreateMap(); var map = sMapManager.CreateMap();
@@ -98,7 +70,7 @@ namespace Content.IntegrationTests.Tests.Networking
}); });
// Run some ticks so that // Run some ticks so that
await RunTicksSync(client, server, 3); await PoolManager.RunTicksSync(pairTracker.Pair, 3);
// Due to technical things with the game state processor it has an extra state in the buffer here. // Due to technical things with the game state processor it has an extra state in the buffer here.
// This burns through it real quick, but I'm not sure it should be there? // This burns through it real quick, but I'm not sure it should be there?
@@ -387,10 +359,11 @@ namespace Content.IntegrationTests.Tests.Networking
Assert.That(clientComponent.Foo, Is.True); Assert.That(clientComponent.Foo, Is.True);
} }
} }
await pairTracker.CleanReturnAsync();
} }
[NetworkedComponent()] [NetworkedComponent()]
private sealed class PredictionTestComponent : Component public sealed class PredictionTestComponent : Component
{ {
private bool _foo; private bool _foo;
@@ -432,7 +405,7 @@ namespace Content.IntegrationTests.Tests.Networking
} }
[Reflect(false)] [Reflect(false)]
private sealed class PredictionTestEntitySystem : EntitySystem public sealed class PredictionTestEntitySystem : EntitySystem
{ {
public bool Allow { get; set; } = true; public bool Allow { get; set; } = true;

107
Content.IntegrationTests/Tests/PostMapInitTest.cs
View File

@@ -1,6 +1,8 @@
using System; using System;
using System.Collections.Generic;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using NUnit.Framework; using NUnit.Framework;
using Robust.Server.Maps; using Robust.Server.Maps;
@@ -12,7 +14,7 @@ using YamlDotNet.RepresentationModel;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class PostMapInitTest : ContentIntegrationTest public sealed class PostMapInitTest
{ {
public const bool SkipTestMaps = true; public const bool SkipTestMaps = true;
public const string TestMapsPath = "/Maps/Test/"; public const string TestMapsPath = "/Maps/Test/";
@@ -20,9 +22,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task NoSavedPostMapInitTest() public async Task NoSavedPostMapInitTest()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var resourceManager = server.ResolveDependency<IResourceManager>(); var resourceManager = server.ResolveDependency<IResourceManager>();
var mapFolder = new ResourcePath("/Maps"); var mapFolder = new ResourcePath("/Maps");
@@ -57,56 +58,80 @@ namespace Content.IntegrationTests.Tests
Assert.False(postMapInit, $"Map {map.Filename} was saved postmapinit"); Assert.False(postMapInit, $"Map {map.Filename} was saved postmapinit");
} }
await pairTracker.CleanReturnAsync();
} }
[Test] private static string[] GetMapNames()
public async Task MapsLoadableTest()
{ {
var server = StartServer(); Task<string[]> task = null;
using (ExecutionContext.SuppressFlow())
{
task = Task.Run(static async () =>
{
await Task.Yield();
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{Disconnected = true});
var server = pairTracker.Pair.Server;
var resourceManager = server.ResolveDependency<IResourceManager>();
var mapFolder = new ResourcePath("/Maps");
var maps = resourceManager
.ContentFindFiles(mapFolder)
.Where(filePath => filePath.Extension == "yml" && !filePath.Filename.StartsWith("."))
.ToArray();
var mapNames = new List<string>();
foreach (var map in maps)
{
var rootedPath = map.ToRootedPath();
await server.WaitIdleAsync(); // ReSharper disable once RedundantLogicalConditionalExpressionOperand
if (SkipTestMaps && rootedPath.ToString().StartsWith(TestMapsPath))
{
continue;
}
mapNames.Add(rootedPath.ToString());
}
await pairTracker.CleanReturnAsync();
return mapNames.ToArray();
});
Task.WaitAll(task);
}
return task.GetAwaiter().GetResult();
}
[Test, TestCaseSource("GetMapNames")]
public async Task MapsLoadableTest(string mapName)
{
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
var mapLoader = server.ResolveDependency<IMapLoader>(); var mapLoader = server.ResolveDependency<IMapLoader>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var resourceManager = server.ResolveDependency<IResourceManager>();
var mapFolder = new ResourcePath("/Maps");
var maps = resourceManager
.ContentFindFiles(mapFolder)
.Where(filePath => filePath.Extension == "yml" && !filePath.Filename.StartsWith("."))
.ToArray();
foreach (var map in maps) await server.WaitPost(() =>
{ {
var rootedPath = map.ToRootedPath(); var mapId = mapManager.CreateMap();
try
// ReSharper disable once RedundantLogicalConditionalExpressionOperand
if (SkipTestMaps && rootedPath.ToString().StartsWith(TestMapsPath))
{ {
continue; mapLoader.LoadMap(mapId, mapName);
}
catch (Exception ex)
{
throw new Exception($"Failed to load map {mapName}", ex);
} }
server.Post(() => try
{ {
var mapId = mapManager.CreateMap(); mapManager.DeleteMap(mapId);
try }
{ catch (Exception ex)
mapLoader.LoadMap(mapId, rootedPath.ToString()); {
} throw new Exception($"Failed to delete map {mapName}", ex);
catch (Exception ex) }
{ });
throw new Exception($"Failed to load map {rootedPath}", ex); await server.WaitRunTicks(1);
}
try await pairTracker.CleanReturnAsync();
{
mapManager.DeleteMap(mapId);
}
catch (Exception ex)
{
throw new Exception($"Failed to delete map {rootedPath}", ex);
}
});
await server.WaitIdleAsync();
}
} }
} }
} }

506
Content.IntegrationTests/Tests/Power/PowerTest.cs
View File

@@ -14,9 +14,8 @@ using Robust.Shared.Timing;
namespace Content.IntegrationTests.Tests.Power namespace Content.IntegrationTests.Tests.Power
{ {
[Parallelizable(ParallelScope.Fixtures)]
[TestFixture] [TestFixture]
public sealed class PowerTest : ContentIntegrationTest public sealed class PowerTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: entity - type: entity
@@ -157,56 +156,40 @@ namespace Content.IntegrationTests.Tests.Power
- type: Transform - type: Transform
anchored: true anchored: true
"; ";
private ServerIntegrationInstance _server = default!;
private IMapManager _mapManager = default!;
private IEntityManager _entityManager = default!;
private IGameTiming _gameTiming = default!;
private ExtensionCableSystem _extensionCableSystem = default!;
[OneTimeSetUp]
public async Task Setup()
{
var options = new ServerIntegrationOptions {ExtraPrototypes = Prototypes};
_server = StartServer(options);
await _server.WaitIdleAsync();
_mapManager = _server.ResolveDependency<IMapManager>();
_entityManager = _server.ResolveDependency<IEntityManager>();
_gameTiming = _server.ResolveDependency<IGameTiming>();
_extensionCableSystem = _entityManager.EntitySysManager.GetEntitySystem<ExtensionCableSystem>();
}
/// <summary> /// <summary>
/// Test small power net with a simple surplus of power over the loads. /// Test small power net with a simple surplus of power over the loads.
/// </summary> /// </summary>
[Test] [Test]
public async Task TestSimpleSurplus() public async Task TestSimpleSurplus()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
const float loadPower = 200; const float loadPower = 200;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer1 = default!; PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!; PowerConsumerComponent consumer2 = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var generatorEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates()); var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates());
var consumerEnt1 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 1)); var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 1));
var consumerEnt2 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2)); var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2));
supplier = _entityManager.GetComponent<PowerSupplierComponent>(generatorEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer1 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1); consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2); consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
// Plenty of surplus and tolerance // Plenty of surplus and tolerance
supplier.MaxSupply = loadPower * 4; supplier.MaxSupply = loadPower * 4;
@@ -215,9 +198,9 @@ namespace Content.IntegrationTests.Tests.Power
consumer2.DrawRate = loadPower; consumer2.DrawRate = loadPower;
}); });
_server.RunTicks(1); //let run a tick for PowerNet to process power server.RunTicks(1); //let run a tick for PowerNet to process power
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// Assert both consumers fully powered // Assert both consumers fully powered
Assert.That(consumer1.ReceivedPower, Is.EqualTo(consumer1.DrawRate).Within(0.1)); Assert.That(consumer1.ReceivedPower, Is.EqualTo(consumer1.DrawRate).Within(0.1));
@@ -227,7 +210,7 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(supplier.CurrentSupply, Is.EqualTo(loadPower * 2).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(loadPower * 2).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
@@ -237,30 +220,34 @@ namespace Content.IntegrationTests.Tests.Power
[Test] [Test]
public async Task TestSimpleDeficit() public async Task TestSimpleDeficit()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
const float loadPower = 200; const float loadPower = 200;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer1 = default!; PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!; PowerConsumerComponent consumer2 = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var generatorEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates()); var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates());
var consumerEnt1 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 1)); var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 1));
var consumerEnt2 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2)); var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2));
supplier = _entityManager.GetComponent<PowerSupplierComponent>(generatorEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer1 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1); consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2); consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
// Too little supply, both consumers should get 33% power. // Too little supply, both consumers should get 33% power.
supplier.MaxSupply = loadPower; supplier.MaxSupply = loadPower;
@@ -269,9 +256,9 @@ namespace Content.IntegrationTests.Tests.Power
consumer2.DrawRate = loadPower * 2; consumer2.DrawRate = loadPower * 2;
}); });
_server.RunTicks(1); //let run a tick for PowerNet to process power server.RunTicks(1); //let run a tick for PowerNet to process power
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// Assert both consumers get 33% power. // Assert both consumers get 33% power.
Assert.That(consumer1.ReceivedPower, Is.EqualTo(consumer1.DrawRate / 3).Within(0.1)); Assert.That(consumer1.ReceivedPower, Is.EqualTo(consumer1.DrawRate / 3).Within(0.1));
@@ -281,32 +268,37 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestSupplyRamp() public async Task TestSupplyRamp()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerConsumerComponent consumer = default!; PowerConsumerComponent consumer = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var generatorEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates()); var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates());
var consumerEnt = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2)); var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2));
supplier = _entityManager.GetComponent<PowerSupplierComponent>(generatorEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
consumer = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt); consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
// Supply has enough total power but needs to ramp up to match. // Supply has enough total power but needs to ramp up to match.
supplier.MaxSupply = 400; supplier.MaxSupply = 400;
@@ -316,21 +308,21 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Exact values can/will be off by a tick, add tolerance for that. // Exact values can/will be off by a tick, add tolerance for that.
var tickRate = (float) _gameTiming.TickPeriod.TotalSeconds; var tickRate = (float) gameTiming.TickPeriod.TotalSeconds;
var tickDev = 400 * tickRate * 1.1f; var tickDev = 400 * tickRate * 1.1f;
_server.RunTicks(1); server.RunTicks(1);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// First tick, supply should be delivering 100 W (max tolerance) and start ramping up. // First tick, supply should be delivering 100 W (max tolerance) and start ramping up.
Assert.That(supplier.CurrentSupply, Is.EqualTo(100).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(100).Within(0.1));
Assert.That(consumer.ReceivedPower, Is.EqualTo(100).Within(0.1)); Assert.That(consumer.ReceivedPower, Is.EqualTo(100).Within(0.1));
}); });
_server.RunTicks(14); server.RunTicks(14);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// After 15 ticks (0.25 seconds), supply ramp pos should be at 100 W and supply at 100, approx. // After 15 ticks (0.25 seconds), supply ramp pos should be at 100 W and supply at 100, approx.
Assert.That(supplier.CurrentSupply, Is.EqualTo(200).Within(tickDev)); Assert.That(supplier.CurrentSupply, Is.EqualTo(200).Within(tickDev));
@@ -338,9 +330,9 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(consumer.ReceivedPower, Is.EqualTo(200).Within(tickDev)); Assert.That(consumer.ReceivedPower, Is.EqualTo(200).Within(tickDev));
}); });
_server.RunTicks(45); server.RunTicks(45);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// After 1 second total, ramp should be at 400 and supply should be at 400, everybody happy. // After 1 second total, ramp should be at 400 and supply should be at 400, everybody happy.
Assert.That(supplier.CurrentSupply, Is.EqualTo(400).Within(tickDev)); Assert.That(supplier.CurrentSupply, Is.EqualTo(400).Within(tickDev));
@@ -348,36 +340,41 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(consumer.ReceivedPower, Is.EqualTo(400).Within(tickDev)); Assert.That(consumer.ReceivedPower, Is.EqualTo(400).Within(tickDev));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestBatteryRamp() public async Task TestBatteryRamp()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
const float startingCharge = 100_000; const float startingCharge = 100_000;
PowerNetworkBatteryComponent netBattery = default!; PowerNetworkBatteryComponent netBattery = default!;
BatteryComponent battery = default!; BatteryComponent battery = default!;
PowerConsumerComponent consumer = default!; PowerConsumerComponent consumer = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var generatorEnt = _entityManager.SpawnEntity("DischargingBatteryDummy", grid.ToCoordinates()); var generatorEnt = entityManager.SpawnEntity("DischargingBatteryDummy", grid.ToCoordinates());
var consumerEnt = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2)); var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 2));
netBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(generatorEnt); netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(generatorEnt);
battery = _entityManager.GetComponent<BatteryComponent>(generatorEnt); battery = entityManager.GetComponent<BatteryComponent>(generatorEnt);
consumer = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt); consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
battery.MaxCharge = startingCharge; battery.MaxCharge = startingCharge;
battery.CurrentCharge = startingCharge; battery.CurrentCharge = startingCharge;
@@ -388,21 +385,21 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Exact values can/will be off by a tick, add tolerance for that. // Exact values can/will be off by a tick, add tolerance for that.
var tickRate = (float) _gameTiming.TickPeriod.TotalSeconds; var tickRate = (float) gameTiming.TickPeriod.TotalSeconds;
var tickDev = 400 * tickRate * 1.1f; var tickDev = 400 * tickRate * 1.1f;
_server.RunTicks(1); server.RunTicks(1);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// First tick, supply should be delivering 100 W (max tolerance) and start ramping up. // First tick, supply should be delivering 100 W (max tolerance) and start ramping up.
Assert.That(netBattery.CurrentSupply, Is.EqualTo(100).Within(0.1)); Assert.That(netBattery.CurrentSupply, Is.EqualTo(100).Within(0.1));
Assert.That(consumer.ReceivedPower, Is.EqualTo(100).Within(0.1)); Assert.That(consumer.ReceivedPower, Is.EqualTo(100).Within(0.1));
}); });
_server.RunTicks(14); server.RunTicks(14);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// After 15 ticks (0.25 seconds), supply ramp pos should be at 100 W and supply at 100, approx. // After 15 ticks (0.25 seconds), supply ramp pos should be at 100 W and supply at 100, approx.
Assert.That(netBattery.CurrentSupply, Is.EqualTo(200).Within(tickDev)); Assert.That(netBattery.CurrentSupply, Is.EqualTo(200).Within(tickDev));
@@ -414,9 +411,9 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(battery.CurrentCharge, Is.EqualTo(startingCharge - spentExpected).Within(tickDev)); Assert.That(battery.CurrentCharge, Is.EqualTo(startingCharge - spentExpected).Within(tickDev));
}); });
_server.RunTicks(45); server.RunTicks(45);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// After 1 second total, ramp should be at 400 and supply should be at 400, everybody happy. // After 1 second total, ramp should be at 400 and supply should be at 400, everybody happy.
Assert.That(netBattery.CurrentSupply, Is.EqualTo(400).Within(tickDev)); Assert.That(netBattery.CurrentSupply, Is.EqualTo(400).Within(tickDev));
@@ -428,34 +425,38 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(battery.CurrentCharge, Is.EqualTo(startingCharge - spentExpected).Within(tickDev)); Assert.That(battery.CurrentCharge, Is.EqualTo(startingCharge - spentExpected).Within(tickDev));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestSimpleBatteryChargeDeficit() public async Task TestSimpleBatteryChargeDeficit()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
BatteryComponent battery = default!; BatteryComponent battery = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var generatorEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates()); var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates());
var batteryEnt = _entityManager.SpawnEntity("ChargingBatteryDummy", grid.ToCoordinates(0, 2)); var batteryEnt = entityManager.SpawnEntity("ChargingBatteryDummy", grid.ToCoordinates(0, 2));
supplier = _entityManager.GetComponent<PowerSupplierComponent>(generatorEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
var netBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt); var netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
battery = _entityManager.GetComponent<BatteryComponent>(batteryEnt); battery = entityManager.GetComponent<BatteryComponent>(batteryEnt);
supplier.MaxSupply = 500; supplier.MaxSupply = 500;
supplier.SupplyRampTolerance = 500; supplier.SupplyRampTolerance = 500;
@@ -464,9 +465,9 @@ namespace Content.IntegrationTests.Tests.Power
netBattery.Efficiency = 0.5f; netBattery.Efficiency = 0.5f;
}); });
_server.RunTicks(30); // 60 TPS, 0.5 seconds server.RunTicks(30); // 60 TPS, 0.5 seconds
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// half a second @ 500 W = 250 // half a second @ 500 W = 250
// 50% efficiency, so 125 J stored total. // 50% efficiency, so 125 J stored total.
@@ -474,40 +475,45 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(supplier.CurrentSupply, Is.EqualTo(500).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(500).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestFullBattery() public async Task TestFullBattery()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
PowerConsumerComponent consumer = default!; PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!; PowerNetworkBatteryComponent netBattery = default!;
BatteryComponent battery = default!; BatteryComponent battery = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 4; i++) for (var i = 0; i < 4; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var batteryEnt = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2)); var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2));
var supplyEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0)); var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0));
var consumerEnt = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3)); var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3));
consumer = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt); consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = _entityManager.GetComponent<PowerSupplierComponent>(supplyEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
netBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt); netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
battery = _entityManager.GetComponent<BatteryComponent>(batteryEnt); battery = entityManager.GetComponent<BatteryComponent>(batteryEnt);
// Consumer needs 1000 W, supplier can only provide 800, battery fills in the remaining 200. // Consumer needs 1000 W, supplier can only provide 800, battery fills in the remaining 200.
consumer.DrawRate = 1000; consumer.DrawRate = 1000;
@@ -522,13 +528,13 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Run some ticks so everything is stable. // Run some ticks so everything is stable.
_server.RunTicks(60); server.RunTicks(60);
// Exact values can/will be off by a tick, add tolerance for that. // Exact values can/will be off by a tick, add tolerance for that.
var tickRate = (float) _gameTiming.TickPeriod.TotalSeconds; var tickRate = (float) gameTiming.TickPeriod.TotalSeconds;
var tickDev = 400 * tickRate * 1.1f; var tickDev = 400 * tickRate * 1.1f;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(consumer.ReceivedPower, Is.EqualTo(consumer.DrawRate).Within(0.1)); Assert.That(consumer.ReceivedPower, Is.EqualTo(consumer.DrawRate).Within(0.1));
Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1));
@@ -542,40 +548,45 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(battery.CurrentCharge, Is.EqualTo(battery.MaxCharge - expectedSpent).Within(tickDev)); Assert.That(battery.CurrentCharge, Is.EqualTo(battery.MaxCharge - expectedSpent).Within(tickDev));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestFullBatteryEfficiencyPassThrough() public async Task TestFullBatteryEfficiencyPassThrough()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var gameTiming = server.ResolveDependency<IGameTiming>();
PowerConsumerComponent consumer = default!; PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!; PowerNetworkBatteryComponent netBattery = default!;
BatteryComponent battery = default!; BatteryComponent battery = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 4; i++) for (var i = 0; i < 4; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var batteryEnt = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2)); var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2));
var supplyEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0)); var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0));
var consumerEnt = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3)); var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3));
consumer = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt); consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = _entityManager.GetComponent<PowerSupplierComponent>(supplyEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
netBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt); netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
battery = _entityManager.GetComponent<BatteryComponent>(batteryEnt); battery = entityManager.GetComponent<BatteryComponent>(batteryEnt);
// Consumer needs 1000 W, supply and battery can only provide 400 each. // Consumer needs 1000 W, supply and battery can only provide 400 each.
// BUT the battery has 50% input efficiency, so 50% of the power of the supply gets lost. // BUT the battery has 50% input efficiency, so 50% of the power of the supply gets lost.
@@ -592,13 +603,13 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Run some ticks so everything is stable. // Run some ticks so everything is stable.
_server.RunTicks(60); server.RunTicks(60);
// Exact values can/will be off by a tick, add tolerance for that. // Exact values can/will be off by a tick, add tolerance for that.
var tickRate = (float) _gameTiming.TickPeriod.TotalSeconds; var tickRate = (float) gameTiming.TickPeriod.TotalSeconds;
var tickDev = 400 * tickRate * 1.1f; var tickDev = 400 * tickRate * 1.1f;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(consumer.ReceivedPower, Is.EqualTo(600).Within(0.1)); Assert.That(consumer.ReceivedPower, Is.EqualTo(600).Within(0.1));
Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1));
@@ -610,20 +621,24 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(battery.CurrentCharge, Is.EqualTo(battery.MaxCharge - expectedSpent).Within(tickDev)); Assert.That(battery.CurrentCharge, Is.EqualTo(battery.MaxCharge - expectedSpent).Within(tickDev));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestFullBatteryEfficiencyDemandPassThrough() public async Task TestFullBatteryEfficiencyDemandPassThrough()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
PowerConsumerComponent consumer1 = default!; PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!; PowerConsumerComponent consumer2 = default!;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Map layout here is // Map layout here is
// C - consumer // C - consumer
@@ -637,26 +652,26 @@ namespace Content.IntegrationTests.Tests.Power
for (var i = 0; i < 5; i++) for (var i = 0; i < 5; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
_entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2)); entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2));
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var batteryEnt1 = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 1)); var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 1));
var batteryEnt2 = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 3)); var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 3));
var supplyEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 2)); var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 2));
var consumerEnt1 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 0)); var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 0));
var consumerEnt2 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 4)); var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 4));
consumer1 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1); consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2); consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
supplier = _entityManager.GetComponent<PowerSupplierComponent>(supplyEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
var netBattery1 = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt1); var netBattery1 = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt1);
var netBattery2 = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt2); var netBattery2 = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt2);
var battery1 = _entityManager.GetComponent<BatteryComponent>(batteryEnt1); var battery1 = entityManager.GetComponent<BatteryComponent>(batteryEnt1);
var battery2 = _entityManager.GetComponent<BatteryComponent>(batteryEnt2); var battery2 = entityManager.GetComponent<BatteryComponent>(batteryEnt2);
// There are two loads, 500 W and 1000 W respectively. // There are two loads, 500 W and 1000 W respectively.
// The 500 W load is behind a 50% efficient battery, // The 500 W load is behind a 50% efficient battery,
@@ -685,16 +700,16 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Run some ticks so everything is stable. // Run some ticks so everything is stable.
_server.RunTicks(10); server.RunTicks(10);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(consumer1.ReceivedPower, Is.EqualTo(250).Within(0.1)); Assert.That(consumer1.ReceivedPower, Is.EqualTo(250).Within(0.1));
Assert.That(consumer2.ReceivedPower, Is.EqualTo(500).Within(0.1)); Assert.That(consumer2.ReceivedPower, Is.EqualTo(500).Within(0.1));
Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
/// <summary> /// <summary>
@@ -703,14 +718,18 @@ namespace Content.IntegrationTests.Tests.Power
[Test] [Test]
public async Task TestBatteriesProportional() public async Task TestBatteriesProportional()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
PowerConsumerComponent consumer1 = default!; PowerConsumerComponent consumer1 = default!;
PowerConsumerComponent consumer2 = default!; PowerConsumerComponent consumer2 = default!;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Map layout here is // Map layout here is
// C - consumer // C - consumer
@@ -724,26 +743,26 @@ namespace Content.IntegrationTests.Tests.Power
for (var i = 0; i < 5; i++) for (var i = 0; i < 5; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
_entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2)); entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2));
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 2));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var batteryEnt1 = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 1)); var batteryEnt1 = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 1));
var batteryEnt2 = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 3)); var batteryEnt2 = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 3));
var supplyEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 2)); var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 2));
var consumerEnt1 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 0)); var consumerEnt1 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 0));
var consumerEnt2 = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 4)); var consumerEnt2 = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 4));
consumer1 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1); consumer1 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt1);
consumer2 = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2); consumer2 = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt2);
supplier = _entityManager.GetComponent<PowerSupplierComponent>(supplyEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
var netBattery1 = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt1); var netBattery1 = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt1);
var netBattery2 = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt2); var netBattery2 = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt2);
var battery1 = _entityManager.GetComponent<BatteryComponent>(batteryEnt1); var battery1 = entityManager.GetComponent<BatteryComponent>(batteryEnt1);
var battery2 = _entityManager.GetComponent<BatteryComponent>(batteryEnt2); var battery2 = entityManager.GetComponent<BatteryComponent>(batteryEnt2);
consumer1.DrawRate = 500; consumer1.DrawRate = 500;
consumer2.DrawRate = 1000; consumer2.DrawRate = 1000;
@@ -764,9 +783,9 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Run some ticks so everything is stable. // Run some ticks so everything is stable.
_server.RunTicks(60); server.RunTicks(60);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// NOTE: MaxChargeRate on batteries actually skews the demand. // NOTE: MaxChargeRate on batteries actually skews the demand.
// So that's why the tolerance is so high, the charge rate is so *low*, // So that's why the tolerance is so high, the charge rate is so *low*,
@@ -776,39 +795,43 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1)); Assert.That(supplier.CurrentSupply, Is.EqualTo(supplier.MaxSupply).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task TestBatteryEngineCut() public async Task TestBatteryEngineCut()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
PowerConsumerComponent consumer = default!; PowerConsumerComponent consumer = default!;
PowerSupplierComponent supplier = default!; PowerSupplierComponent supplier = default!;
PowerNetworkBatteryComponent netBattery = default!; PowerNetworkBatteryComponent netBattery = default!;
_server.Post(() => await server.WaitPost(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 4; i++) for (var i = 0; i < 4; i++)
{ {
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, i));
} }
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var batteryEnt = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2)); var batteryEnt = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2));
var supplyEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0)); var supplyEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0));
var consumerEnt = _entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3)); var consumerEnt = entityManager.SpawnEntity("ConsumerDummy", grid.ToCoordinates(0, 3));
consumer = _entityManager.GetComponent<PowerConsumerComponent>(consumerEnt); consumer = entityManager.GetComponent<PowerConsumerComponent>(consumerEnt);
supplier = _entityManager.GetComponent<PowerSupplierComponent>(supplyEnt); supplier = entityManager.GetComponent<PowerSupplierComponent>(supplyEnt);
netBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt); netBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(batteryEnt);
var battery = _entityManager.GetComponent<BatteryComponent>(batteryEnt); var battery = entityManager.GetComponent<BatteryComponent>(batteryEnt);
// Consumer needs 1000 W, supplier can only provide 800, battery fills in the remaining 200. // Consumer needs 1000 W, supplier can only provide 800, battery fills in the remaining 200.
consumer.DrawRate = 1000; consumer.DrawRate = 1000;
@@ -823,9 +846,9 @@ namespace Content.IntegrationTests.Tests.Power
}); });
// Run some ticks so everything is stable. // Run some ticks so everything is stable.
_server.RunTicks(5); server.RunTicks(5);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// Supply and consumer are fully loaded/supplied. // Supply and consumer are fully loaded/supplied.
Assert.That(consumer.ReceivedPower, Is.EqualTo(consumer.DrawRate).Within(0.5)); Assert.That(consumer.ReceivedPower, Is.EqualTo(consumer.DrawRate).Within(0.5));
@@ -837,9 +860,9 @@ namespace Content.IntegrationTests.Tests.Power
netBattery.SupplyRampTolerance = 5; netBattery.SupplyRampTolerance = 5;
}); });
_server.RunTicks(3); server.RunTicks(3);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
// Assert that network drops to 0 power and starts ramping up // Assert that network drops to 0 power and starts ramping up
Assert.That(consumer.ReceivedPower, Is.LessThan(50).And.GreaterThan(0)); Assert.That(consumer.ReceivedPower, Is.LessThan(50).And.GreaterThan(0));
@@ -847,7 +870,7 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(netBattery.CurrentSupply, Is.GreaterThan(0)); Assert.That(netBattery.CurrentSupply, Is.GreaterThan(0));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
/// <summary> /// <summary>
@@ -856,15 +879,19 @@ namespace Content.IntegrationTests.Tests.Power
[Test] [Test]
public async Task TestTerminalNodeGroups() public async Task TestTerminalNodeGroups()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
CableNode leftNode = default!; CableNode leftNode = default!;
CableNode rightNode = default!; CableNode rightNode = default!;
Node batteryInput = default!; Node batteryInput = default!;
Node batteryOutput = default!; Node batteryOutput = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 4; i++) for (var i = 0; i < 4; i++)
@@ -872,28 +899,28 @@ namespace Content.IntegrationTests.Tests.Power
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
} }
var leftEnt = _entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 0)); var leftEnt = entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 0));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 1)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 1));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 2)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 2));
var rightEnt = _entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 3)); var rightEnt = entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 3));
var terminal = _entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1)); var terminal = entityManager.SpawnEntity("CableTerminal", grid.ToCoordinates(0, 1));
_entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180); entityManager.GetComponent<TransformComponent>(terminal).LocalRotation = Angle.FromDegrees(180);
var battery = _entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2)); var battery = entityManager.SpawnEntity("FullBatteryDummy", grid.ToCoordinates(0, 2));
var batteryNodeContainer = _entityManager.GetComponent<NodeContainerComponent>(battery); var batteryNodeContainer = entityManager.GetComponent<NodeContainerComponent>(battery);
leftNode = _entityManager.GetComponent<NodeContainerComponent>(leftEnt).GetNode<CableNode>("power"); leftNode = entityManager.GetComponent<NodeContainerComponent>(leftEnt).GetNode<CableNode>("power");
rightNode = _entityManager.GetComponent<NodeContainerComponent>(rightEnt).GetNode<CableNode>("power"); rightNode = entityManager.GetComponent<NodeContainerComponent>(rightEnt).GetNode<CableNode>("power");
batteryInput = batteryNodeContainer.GetNode<Node>("input"); batteryInput = batteryNodeContainer.GetNode<Node>("input");
batteryOutput = batteryNodeContainer.GetNode<Node>("output"); batteryOutput = batteryNodeContainer.GetNode<Node>("output");
}); });
// Run ticks to allow node groups to update. // Run ticks to allow node groups to update.
_server.RunTicks(1); server.RunTicks(1);
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(batteryInput.NodeGroup, Is.EqualTo(leftNode.NodeGroup)); Assert.That(batteryInput.NodeGroup, Is.EqualTo(leftNode.NodeGroup));
Assert.That(batteryOutput.NodeGroup, Is.EqualTo(rightNode.NodeGroup)); Assert.That(batteryOutput.NodeGroup, Is.EqualTo(rightNode.NodeGroup));
@@ -901,19 +928,23 @@ namespace Content.IntegrationTests.Tests.Power
Assert.That(leftNode.NodeGroup, Is.Not.EqualTo(rightNode.NodeGroup)); Assert.That(leftNode.NodeGroup, Is.Not.EqualTo(rightNode.NodeGroup));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task ApcChargingTest() public async Task ApcChargingTest()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
PowerNetworkBatteryComponent substationNetBattery = default!; PowerNetworkBatteryComponent substationNetBattery = default!;
BatteryComponent apcBattery = default!; BatteryComponent apcBattery = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
@@ -921,18 +952,18 @@ namespace Content.IntegrationTests.Tests.Power
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
} }
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 0)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 0));
_entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 1)); entityManager.SpawnEntity("CableHV", grid.ToCoordinates(0, 1));
_entityManager.SpawnEntity("CableMV", grid.ToCoordinates(0, 1)); entityManager.SpawnEntity("CableMV", grid.ToCoordinates(0, 1));
_entityManager.SpawnEntity("CableMV", grid.ToCoordinates(0, 2)); entityManager.SpawnEntity("CableMV", grid.ToCoordinates(0, 2));
var generatorEnt = _entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0)); var generatorEnt = entityManager.SpawnEntity("GeneratorDummy", grid.ToCoordinates(0, 0));
var substationEnt = _entityManager.SpawnEntity("SubstationDummy", grid.ToCoordinates(0, 1)); var substationEnt = entityManager.SpawnEntity("SubstationDummy", grid.ToCoordinates(0, 1));
var apcEnt = _entityManager.SpawnEntity("ApcDummy", grid.ToCoordinates(0, 2)); var apcEnt = entityManager.SpawnEntity("ApcDummy", grid.ToCoordinates(0, 2));
var generatorSupplier = _entityManager.GetComponent<PowerSupplierComponent>(generatorEnt); var generatorSupplier = entityManager.GetComponent<PowerSupplierComponent>(generatorEnt);
substationNetBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(substationEnt); substationNetBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(substationEnt);
apcBattery = _entityManager.GetComponent<BatteryComponent>(apcEnt); apcBattery = entityManager.GetComponent<BatteryComponent>(apcEnt);
generatorSupplier.MaxSupply = 1000; generatorSupplier.MaxSupply = 1000;
generatorSupplier.SupplyRampTolerance = 1000; generatorSupplier.SupplyRampTolerance = 1000;
@@ -940,27 +971,32 @@ namespace Content.IntegrationTests.Tests.Power
apcBattery.CurrentCharge = 0; apcBattery.CurrentCharge = 0;
}); });
_server.RunTicks(5); //let run a few ticks for PowerNets to reevaluate and start charging apc server.RunTicks(5); //let run a few ticks for PowerNets to reevaluate and start charging apc
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(substationNetBattery.CurrentSupply, Is.GreaterThan(0)); //substation should be providing power Assert.That(substationNetBattery.CurrentSupply, Is.GreaterThan(0)); //substation should be providing power
Assert.That(apcBattery.CurrentCharge, Is.GreaterThan(0)); //apc battery should have gained charge Assert.That(apcBattery.CurrentCharge, Is.GreaterThan(0)); //apc battery should have gained charge
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task ApcNetTest() public async Task ApcNetTest()
{ {
await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = pairTracker.Pair.Server;
var mapManager = server.ResolveDependency<IMapManager>();
var entityManager = server.ResolveDependency<IEntityManager>();
var extensionCableSystem = entityManager.EntitySysManager.GetEntitySystem<ExtensionCableSystem>();
PowerNetworkBatteryComponent apcNetBattery = default!; PowerNetworkBatteryComponent apcNetBattery = default!;
ApcPowerReceiverComponent receiver = default!; ApcPowerReceiverComponent receiver = default!;
_server.Assert(() => await server.WaitAssertion(() =>
{ {
var map = _mapManager.CreateMap(); var map = mapManager.CreateMap();
var grid = _mapManager.CreateGrid(map); var grid = mapManager.CreateGrid(map);
// Power only works when anchored // Power only works when anchored
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
@@ -968,16 +1004,16 @@ namespace Content.IntegrationTests.Tests.Power
grid.SetTile(new Vector2i(0, i), new Tile(1)); grid.SetTile(new Vector2i(0, i), new Tile(1));
} }
var apcEnt = _entityManager.SpawnEntity("ApcDummy", grid.ToCoordinates(0, 0)); var apcEnt = entityManager.SpawnEntity("ApcDummy", grid.ToCoordinates(0, 0));
var apcExtensionEnt = _entityManager.SpawnEntity("CableApcExtension", grid.ToCoordinates(0, 0)); var apcExtensionEnt = entityManager.SpawnEntity("CableApcExtension", grid.ToCoordinates(0, 0));
var powerReceiverEnt = _entityManager.SpawnEntity("ApcPowerReceiverDummy", grid.ToCoordinates(0, 2)); var powerReceiverEnt = entityManager.SpawnEntity("ApcPowerReceiverDummy", grid.ToCoordinates(0, 2));
receiver = _entityManager.GetComponent<ApcPowerReceiverComponent>(powerReceiverEnt); receiver = entityManager.GetComponent<ApcPowerReceiverComponent>(powerReceiverEnt);
var battery = _entityManager.GetComponent<BatteryComponent>(apcEnt); var battery = entityManager.GetComponent<BatteryComponent>(apcEnt);
apcNetBattery = _entityManager.GetComponent<PowerNetworkBatteryComponent>(apcEnt); apcNetBattery = entityManager.GetComponent<PowerNetworkBatteryComponent>(apcEnt);
_extensionCableSystem.SetProviderTransferRange(apcExtensionEnt, 5); extensionCableSystem.SetProviderTransferRange(apcExtensionEnt, 5);
_extensionCableSystem.SetReceiverReceptionRange(powerReceiverEnt, 5); extensionCableSystem.SetReceiverReceptionRange(powerReceiverEnt, 5);
battery.MaxCharge = 10000; //arbitrary nonzero amount of charge battery.MaxCharge = 10000; //arbitrary nonzero amount of charge
battery.CurrentCharge = battery.MaxCharge; //fill battery battery.CurrentCharge = battery.MaxCharge; //fill battery
@@ -985,15 +1021,15 @@ namespace Content.IntegrationTests.Tests.Power
receiver.Load = 1; //arbitrary small amount of power receiver.Load = 1; //arbitrary small amount of power
}); });
_server.RunTicks(1); //let run a tick for ApcNet to process power server.RunTicks(1); //let run a tick for ApcNet to process power
_server.Assert(() => await server.WaitAssertion(() =>
{ {
Assert.That(receiver.Powered); Assert.That(receiver.Powered);
Assert.That(apcNetBattery.CurrentSupply, Is.EqualTo(1).Within(0.1)); Assert.That(apcNetBattery.CurrentSupply, Is.EqualTo(1).Within(0.1));
}); });
await _server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

16
Content.IntegrationTests/Tests/ResettingEntitySystemTests.cs
View File

@@ -10,10 +10,10 @@ namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(RoundRestartCleanupEvent))] [TestOf(typeof(RoundRestartCleanupEvent))]
public sealed class ResettingEntitySystemTests : ContentIntegrationTest public sealed class ResettingEntitySystemTests
{ {
[Reflect(false)] [Reflect(false)]
private sealed class TestRoundRestartCleanupEvent : EntitySystem public sealed class TestRoundRestartCleanupEvent : EntitySystem
{ {
public bool HasBeenReset { get; set; } public bool HasBeenReset { get; set; }
@@ -33,15 +33,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task ResettingEntitySystemResetTest() public async Task ResettingEntitySystemResetTest()
{ {
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
ContentBeforeIoC = () =>
{
IoCManager.Resolve<IEntitySystemManager>().LoadExtraSystemType<TestRoundRestartCleanupEvent>();
}
});
await server.WaitIdleAsync();
var entitySystemManager = server.ResolveDependency<IEntitySystemManager>(); var entitySystemManager = server.ResolveDependency<IEntitySystemManager>();
var gameTicker = entitySystemManager.GetEntitySystem<GameTicker>(); var gameTicker = entitySystemManager.GetEntitySystem<GameTicker>();
@@ -60,6 +53,7 @@ namespace Content.IntegrationTests.Tests
Assert.True(system.HasBeenReset); Assert.True(system.HasBeenReset);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

10
Content.IntegrationTests/Tests/RestartRoundTest.cs
View File

@@ -7,19 +7,21 @@ using Robust.Shared.IoC;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class RestartRoundTest : ContentIntegrationTest public sealed class RestartRoundTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var (client, server) = await StartConnectedServerClientPair(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
server.Post(() => await server.WaitPost(() =>
{ {
IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<GameTicker>().RestartRound(); IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<GameTicker>().RestartRound();
}); });
await RunTicksSync(client, server, 10); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await pairTracker.CleanReturnAsync();
} }
} }
} }

11
Content.IntegrationTests/Tests/RoundEndTest.cs
View File

@@ -12,14 +12,15 @@ using Robust.Shared.IoC;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class RoundEndTest : ContentIntegrationTest, IEntityEventSubscriber public sealed class RoundEndTest : IEntityEventSubscriber
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var eventCount = 0; await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var (_, server) = await StartConnectedServerClientPair(); var eventCount = 0;
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
@@ -106,10 +107,12 @@ namespace Content.IntegrationTests.Tests
var currentCount = Thread.VolatileRead(ref eventCount); var currentCount = Thread.VolatileRead(ref eventCount);
while (currentCount == Thread.VolatileRead(ref eventCount) && !timeout.IsCompleted) while (currentCount == Thread.VolatileRead(ref eventCount) && !timeout.IsCompleted)
{ {
await server.WaitRunTicks(1); await PoolManager.RunTicksSync(pairTracker.Pair, 5);
} }
if (timeout.IsCompleted) throw new TimeoutException("Event took too long to trigger"); if (timeout.IsCompleted) throw new TimeoutException("Event took too long to trigger");
} }
await pairTracker.CleanReturnAsync();
} }
} }
} }

15
Content.IntegrationTests/Tests/SaveLoadMapTest.cs
View File

@@ -11,24 +11,21 @@ using Robust.Shared.Utility;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
sealed class SaveLoadMapTest : ContentIntegrationTest sealed class SaveLoadMapTest
{ {
[Test] [Test]
public async Task SaveLoadMultiGridMap() public async Task SaveLoadMultiGridMap()
{ {
const string mapPath = @"/Maps/Test/TestMap.yml"; const string mapPath = @"/Maps/Test/TestMap.yml";
var server = StartServer(new ServerContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
FailureLogLevel = LogLevel.Error
});
await server.WaitIdleAsync();
var mapLoader = server.ResolveDependency<IMapLoader>(); var mapLoader = server.ResolveDependency<IMapLoader>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
var resManager = server.ResolveDependency<IResourceManager>(); var resManager = server.ResolveDependency<IResourceManager>();
server.Post(() => await server.WaitPost(() =>
{ {
var dir = new ResourcePath(mapPath).Directory; var dir = new ResourcePath(mapPath).Directory;
resManager.UserData.CreateDir(dir); resManager.UserData.CreateDir(dir);
@@ -54,7 +51,7 @@ namespace Content.IntegrationTests.Tests
}); });
await server.WaitIdleAsync(); await server.WaitIdleAsync();
server.Post(() => await server.WaitPost(() =>
{ {
mapLoader.LoadMap(new MapId(10), mapPath); mapLoader.LoadMap(new MapId(10), mapPath);
}); });
@@ -77,7 +74,7 @@ namespace Content.IntegrationTests.Tests
Assert.That(mapGrid.GetTileRef(new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(2, (TileRenderFlag)1, 254))); Assert.That(mapGrid.GetTileRef(new Vector2i(0, 0)).Tile, Is.EqualTo(new Tile(2, (TileRenderFlag)1, 254)));
} }
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

20
Content.IntegrationTests/Tests/SaveLoadSaveTest.cs
View File

@@ -14,16 +14,16 @@ namespace Content.IntegrationTests.Tests
/// Tests that the /// Tests that the
/// </summary> /// </summary>
[TestFixture] [TestFixture]
public sealed class SaveLoadSaveTest : ContentIntegrationTest public sealed class SaveLoadSaveTest
{ {
[Test] [Test]
public async Task SaveLoadSave() public async Task SaveLoadSave()
{ {
var server = StartServer(new ServerContentIntegrationOption {Pool = false}); await using var pairTracker = await PoolManager.GetServerClient(new (){Fresh = true, Disconnected = true});
await server.WaitIdleAsync(); var server = pairTracker.Pair.Server;
var mapLoader = server.ResolveDependency<IMapLoader>(); var mapLoader = server.ResolveDependency<IMapLoader>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
server.Post(() => await server.WaitPost(() =>
{ {
// TODO: Properly find the "main" station grid. // TODO: Properly find the "main" station grid.
var grid0 = mapManager.GetAllGrids().First(); var grid0 = mapManager.GetAllGrids().First();
@@ -71,6 +71,7 @@ namespace Content.IntegrationTests.Tests
TestContext.Error.WriteLine(twoTmp); TestContext.Error.WriteLine(twoTmp);
} }
}); });
await pairTracker.CleanReturnAsync();
} }
/// <summary> /// <summary>
@@ -79,12 +80,8 @@ namespace Content.IntegrationTests.Tests
[Test] [Test]
public async Task LoadSaveTicksSaveSaltern() public async Task LoadSaveTicksSaveSaltern()
{ {
var server = StartServerDummyTicker(new ServerIntegrationOptions() await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
{ var server = pairTracker.Pair.Server;
// Don't blame me look at SaveLoadMultiGridMap
FailureLogLevel = LogLevel.Error,
});
await server.WaitIdleAsync();
var mapLoader = server.ResolveDependency<IMapLoader>(); var mapLoader = server.ResolveDependency<IMapLoader>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -103,7 +100,7 @@ namespace Content.IntegrationTests.Tests
// Run 5 ticks. // Run 5 ticks.
server.RunTicks(5); server.RunTicks(5);
server.Post(() => await server.WaitPost(() =>
{ {
mapLoader.SaveMap(mapId, "/load save ticks save 2.yml"); mapLoader.SaveMap(mapId, "/load save ticks save 2.yml");
}); });
@@ -144,6 +141,7 @@ namespace Content.IntegrationTests.Tests
TestContext.Error.WriteLine(twoTmp); TestContext.Error.WriteLine(twoTmp);
} }
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

8
Content.IntegrationTests/Tests/ShuttleTest.cs
View File

@@ -10,14 +10,13 @@ using Robust.Shared.Physics;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class ShuttleTest : ContentIntegrationTest public sealed class ShuttleTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapMan = server.ResolveDependency<IMapManager>(); var mapMan = server.ResolveDependency<IMapManager>();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
@@ -43,6 +42,7 @@ namespace Content.IntegrationTests.Tests
{ {
Assert.That<Vector2?>(sEntities.GetComponent<TransformComponent>(gridEnt).LocalPosition, Is.Not.EqualTo(Vector2.Zero)); Assert.That<Vector2?>(sEntities.GetComponent<TransformComponent>(gridEnt).LocalPosition, Is.Not.EqualTo(Vector2.Zero));
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

52
Content.IntegrationTests/Tests/StartTest.cs
View File

@@ -5,48 +5,32 @@ using Robust.Shared.Exceptions;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class StartTest : ContentIntegrationTest public sealed class StartTest
{ {
/// <summary> /// <summary>
/// Test that the server starts. /// Test that the server, and client start, and stop.
/// </summary>
[Test]
public async Task TestServerStart()
{
var server = StartServer(new ServerContentIntegrationOption
{
Pool = false
});
server.RunTicks(5);
await server.WaitIdleAsync();
Assert.That(server.IsAlive);
var runtimeLog = server.ResolveDependency<IRuntimeLog>();
Assert.That(runtimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged.");
server.Stop();
await server.WaitIdleAsync();
Assert.That(!server.IsAlive);
}
/// <summary>
/// Test that the client starts.
/// </summary> /// </summary>
[Test] [Test]
public async Task TestClientStart() public async Task TestClientStart()
{ {
var client = StartClient(new ClientContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{Disconnected = true});
{ var client = pairTracker.Pair.Client;
Pool = false Assert.That(client.IsAlive);
}); await client.WaitRunTicks(5);
Assert.That(client.IsAlive);
var cRuntimeLog = client.ResolveDependency<IRuntimeLog>();
Assert.That(cRuntimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged on client.");
await client.WaitIdleAsync(); await client.WaitIdleAsync();
Assert.That(client.IsAlive); Assert.That(client.IsAlive);
client.RunTicks(5);
await client.WaitIdleAsync(); var server = pairTracker.Pair.Server;
Assert.That(client.IsAlive); Assert.That(server.IsAlive);
var runtimeLog = client.ResolveDependency<IRuntimeLog>(); var sRuntimeLog = server.ResolveDependency<IRuntimeLog>();
Assert.That(runtimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged."); Assert.That(sRuntimeLog.ExceptionCount, Is.EqualTo(0), "No exceptions must be logged on server.");
client.Stop(); await server.WaitIdleAsync();
await client.WaitIdleAsync(); Assert.That(server.IsAlive);
Assert.That(!client.IsAlive);
await pairTracker.CleanReturnAsync();
} }
} }
} }

24
Content.IntegrationTests/Tests/Station/StationJobsTest.cs
View File

@@ -6,7 +6,6 @@ using Content.Server.Maps;
using Content.Server.Station.Systems; using Content.Server.Station.Systems;
using Content.Shared.Preferences; using Content.Shared.Preferences;
using NUnit.Framework; using NUnit.Framework;
using Robust.Server;
using Robust.Shared.GameObjects; using Robust.Shared.GameObjects;
using Robust.Shared.Log; using Robust.Shared.Log;
using Robust.Shared.Map; using Robust.Shared.Map;
@@ -18,7 +17,7 @@ namespace Content.IntegrationTests.Tests.Station;
[TestFixture] [TestFixture]
[TestOf(typeof(StationJobsSystem))] [TestOf(typeof(StationJobsSystem))]
public sealed class StationJobsTest : ContentIntegrationTest public sealed class StationJobsTest
{ {
private const string Prototypes = @" private const string Prototypes = @"
- type: gameMap - type: gameMap
@@ -64,13 +63,10 @@ public sealed class StationJobsTest : ContentIntegrationTest
[Test] [Test]
public async Task AssignJobsTest() public async Task AssignJobsTest()
{ {
var options = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes, Options = new ServerOptions() { LoadContentResources = false }}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var prototypeManager = server.ResolveDependency<IPrototypeManager>(); var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var mapManager = server.ResolveDependency<IMapManager>();
var fooStationProto = prototypeManager.Index<GameMapPrototype>("FooStation"); var fooStationProto = prototypeManager.Index<GameMapPrototype>("FooStation");
var entSysMan = server.ResolveDependency<IEntityManager>().EntitySysManager; var entSysMan = server.ResolveDependency<IEntityManager>().EntitySysManager;
var stationJobs = entSysMan.GetEntitySystem<StationJobsSystem>(); var stationJobs = entSysMan.GetEntitySystem<StationJobsSystem>();
@@ -79,7 +75,6 @@ public sealed class StationJobsTest : ContentIntegrationTest
List<EntityUid> stations = new(); List<EntityUid> stations = new();
await server.WaitPost(() => await server.WaitPost(() =>
{ {
mapManager.CreateNewMapEntity(MapId.Nullspace);
for (var i = 0; i < StationCount; i++) for (var i = 0; i < StationCount; i++)
{ {
stations.Add(stationSystem.InitializeNewStation(fooStationProto.Stations["Station"], null, $"Foo {StationCount}")); stations.Add(stationSystem.InitializeNewStation(fooStationProto.Stations["Station"], null, $"Foo {StationCount}"));
@@ -88,7 +83,6 @@ public sealed class StationJobsTest : ContentIntegrationTest
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var fakePlayers = new Dictionary<NetUserId, HumanoidCharacterProfile>() var fakePlayers = new Dictionary<NetUserId, HumanoidCharacterProfile>()
.AddJob("TAssistant", JobPriority.Medium, PlayerCount) .AddJob("TAssistant", JobPriority.Medium, PlayerCount)
.AddPreference("TClown", JobPriority.Low) .AddPreference("TClown", JobPriority.Low)
@@ -97,10 +91,12 @@ public sealed class StationJobsTest : ContentIntegrationTest
new Dictionary<NetUserId, HumanoidCharacterProfile>() new Dictionary<NetUserId, HumanoidCharacterProfile>()
.AddJob("TCaptain", JobPriority.High, CaptainCount) .AddJob("TCaptain", JobPriority.High, CaptainCount)
); );
Assert.That(fakePlayers, Is.Not.Empty);
var start = new Stopwatch(); var start = new Stopwatch();
start.Start(); start.Start();
var assigned = stationJobs.AssignJobs(fakePlayers, stations); var assigned = stationJobs.AssignJobs(fakePlayers, stations);
Assert.That(assigned, Is.Not.Empty);
var time = start.Elapsed.TotalMilliseconds; var time = start.Elapsed.TotalMilliseconds;
Logger.Info($"Took {time} ms to distribute {TotalPlayers} players."); Logger.Info($"Took {time} ms to distribute {TotalPlayers} players.");
@@ -131,15 +127,14 @@ public sealed class StationJobsTest : ContentIntegrationTest
// There must be captains present, too. // There must be captains present, too.
Assert.That(assigned.Values.Select(x => x.Item1).ToList(), Does.Contain("TCaptain")); Assert.That(assigned.Values.Select(x => x.Item1).ToList(), Does.Contain("TCaptain"));
}); });
await pairTracker.CleanReturnAsync();
} }
[Test] [Test]
public async Task AdjustJobsTest() public async Task AdjustJobsTest()
{ {
var options = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes, Options = new ServerOptions() { LoadContentResources = false }}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var prototypeManager = server.ResolveDependency<IPrototypeManager>(); var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
@@ -155,6 +150,8 @@ public sealed class StationJobsTest : ContentIntegrationTest
station = stationSystem.InitializeNewStation(fooStationProto.Stations["Station"], null, $"Foo Station"); station = stationSystem.InitializeNewStation(fooStationProto.Stations["Station"], null, $"Foo Station");
}); });
await server.WaitRunTicks(1);
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
// Verify jobs are/are not unlimited. // Verify jobs are/are not unlimited.
@@ -182,6 +179,7 @@ public sealed class StationJobsTest : ContentIntegrationTest
Assert.That(stationJobs.IsJobUnlimited(station, "TChaplain"), "Could not make TChaplain unlimited."); Assert.That(stationJobs.IsJobUnlimited(station, "TChaplain"), "Could not make TChaplain unlimited.");
}); });
}); });
await pairTracker.CleanReturnAsync();
} }
} }

9
Content.IntegrationTests/Tests/StationEvents/StationEventsSystemTest.cs
View File

@@ -9,14 +9,15 @@ using Robust.Shared.Timing;
namespace Content.IntegrationTests.Tests.StationEvents namespace Content.IntegrationTests.Tests.StationEvents
{ {
[TestFixture] [TestFixture]
public sealed class StationEventsSystemTest : ContentIntegrationTest public sealed class StationEventsSystemTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
server.Assert(() => await server.WaitAssertion(() =>
{ {
// Idle each event // Idle each event
var stationEventsSystem = EntitySystem.Get<StationEventSystem>(); var stationEventsSystem = EntitySystem.Get<StationEventSystem>();
@@ -42,7 +43,7 @@ namespace Content.IntegrationTests.Tests.StationEvents
} }
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

8
Content.IntegrationTests/Tests/StorageFillTest.cs
View File

@@ -7,13 +7,14 @@ using Robust.Shared.Prototypes;
namespace Content.IntegrationTests.Tests namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
public sealed class StorageFillTest : ContentIntegrationTest public sealed class StorageFillTest
{ {
[Test] [Test]
public async Task TestStorageFillPrototypes() public async Task TestStorageFillPrototypes()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
await server.WaitIdleAsync(); var server = pairTracker.Pair.Server;
var protoManager = server.ResolveDependency<IPrototypeManager>(); var protoManager = server.ResolveDependency<IPrototypeManager>();
await server.WaitAssertion(() => await server.WaitAssertion(() =>
@@ -29,6 +30,7 @@ namespace Content.IntegrationTests.Tests
} }
} }
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

12
Content.IntegrationTests/Tests/Tag/TagTest.cs
View File

@@ -11,7 +11,7 @@ namespace Content.IntegrationTests.Tests.Tag
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(TagComponent))] [TestOf(typeof(TagComponent))]
public sealed class TagTest : ContentIntegrationTest public sealed class TagTest
{ {
private const string TagEntityId = "TagTestDummy"; private const string TagEntityId = "TagTestDummy";
@@ -44,15 +44,13 @@ namespace Content.IntegrationTests.Tests.Tag
[Test] [Test]
public async Task TagComponentTest() public async Task TagComponentTest()
{ {
var options = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(options); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
var sPrototypeManager = server.ResolveDependency<IPrototypeManager>(); var sPrototypeManager = server.ResolveDependency<IPrototypeManager>();
var tagSystem = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<TagSystem>(); var entManager = server.ResolveDependency<IEntitySystemManager>();
EntityUid sTagDummy = default; EntityUid sTagDummy = default;
TagComponent sTagComponent = null!; TagComponent sTagComponent = null!;
@@ -66,6 +64,7 @@ namespace Content.IntegrationTests.Tests.Tag
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var tagSystem = entManager.GetEntitySystem<TagSystem>();
// Has one tag, the starting tag // Has one tag, the starting tag
Assert.That(sTagComponent.Tags.Count, Is.EqualTo(1)); Assert.That(sTagComponent.Tags.Count, Is.EqualTo(1));
sPrototypeManager.Index<TagPrototype>(StartingTag); sPrototypeManager.Index<TagPrototype>(StartingTag);
@@ -218,6 +217,7 @@ namespace Content.IntegrationTests.Tests.Tag
// No tags left in the component // No tags left in the component
Assert.That(sTagComponent.Tags, Is.Empty); Assert.That(sTagComponent.Tags, Is.Empty);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

15
Content.IntegrationTests/Tests/Utility/EntitySystemExtensionsTest.cs
View File

@@ -12,7 +12,7 @@ namespace Content.IntegrationTests.Tests.Utility
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(EntitySystemExtensions))] [TestOf(typeof(EntitySystemExtensions))]
public sealed class EntitySystemExtensionsTest : ContentIntegrationTest public sealed class EntitySystemExtensionsTest
{ {
private const string BlockerDummyId = "BlockerDummy"; private const string BlockerDummyId = "BlockerDummy";
@@ -34,10 +34,8 @@ namespace Content.IntegrationTests.Tests.Utility
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var serverOptions = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(serverOptions); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
var sEntityManager = server.ResolveDependency<IEntityManager>(); var sEntityManager = server.ResolveDependency<IEntityManager>();
@@ -45,17 +43,17 @@ namespace Content.IntegrationTests.Tests.Utility
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var grid = GetMainGrid(sMapManager); var grid = PoolManager.GetMainGrid(sMapManager);
var gridEnt = grid.GridEntityId; var gridEnt = grid.GridEntityId;
var gridPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(gridEnt).WorldPosition; var gridPos = IoCManager.Resolve<IEntityManager>().GetComponent<TransformComponent>(gridEnt).WorldPosition;
var entityCoordinates = GetMainEntityCoordinates(sMapManager); var entityCoordinates = PoolManager.GetMainEntityCoordinates(sMapManager);
// Nothing blocking it, only entity is the grid // Nothing blocking it, only entity is the grid
Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable)); Assert.NotNull(sEntityManager.SpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable));
Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out var entity)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, entityCoordinates, CollisionGroup.Impassable, out var entity));
Assert.NotNull(entity); Assert.NotNull(entity);
var mapId = GetMainMapId(sMapManager); var mapId = PoolManager.GetMainGrid(sMapManager).ParentMapId;
var mapCoordinates = new MapCoordinates(gridPos.X, gridPos.Y, mapId); var mapCoordinates = new MapCoordinates(gridPos.X, gridPos.Y, mapId);
// Nothing blocking it, only entity is the grid // Nothing blocking it, only entity is the grid
@@ -85,6 +83,7 @@ namespace Content.IntegrationTests.Tests.Utility
Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MidImpassable, out entity)); Assert.True(sEntityManager.TrySpawnIfUnobstructed(null, mapCoordinates, CollisionGroup.MidImpassable, out entity));
Assert.NotNull(entity); Assert.NotNull(entity);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

10
Content.IntegrationTests/Tests/Utility/EntityWhitelistTest.cs
View File

@@ -10,7 +10,7 @@ namespace Content.IntegrationTests.Tests.Utility
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(EntityWhitelist))] [TestOf(typeof(EntityWhitelist))]
public sealed class EntityWhitelistTest : ContentIntegrationTest public sealed class EntityWhitelistTest
{ {
private const string InvalidComponent = "Sprite"; private const string InvalidComponent = "Sprite";
private const string ValidComponent = "Physics"; private const string ValidComponent = "Physics";
@@ -60,16 +60,15 @@ namespace Content.IntegrationTests.Tests.Utility
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var serverOptions = new ServerContentIntegrationOption {ExtraPrototypes = Prototypes}; await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true, ExtraPrototypes = Prototypes});
var server = StartServer(serverOptions); var server = pairTracker.Pair.Server;
await server.WaitIdleAsync();
var mapManager = server.ResolveDependency<IMapManager>(); var mapManager = server.ResolveDependency<IMapManager>();
var sEntities = server.ResolveDependency<IEntityManager>(); var sEntities = server.ResolveDependency<IEntityManager>();
await server.WaitAssertion(() => await server.WaitAssertion(() =>
{ {
var mapId = GetMainMapId(mapManager); var mapId = PoolManager.GetMainGrid(mapManager).ParentMapId;
var mapCoordinates = new MapCoordinates(0, 0, mapId); var mapCoordinates = new MapCoordinates(0, 0, mapId);
var validComponent = sEntities.SpawnEntity("ValidComponentDummy", mapCoordinates); var validComponent = sEntities.SpawnEntity("ValidComponentDummy", mapCoordinates);
@@ -110,6 +109,7 @@ namespace Content.IntegrationTests.Tests.Utility
Assert.That(whitelistSer.IsValid(invalidComponent), Is.False); Assert.That(whitelistSer.IsValid(invalidComponent), Is.False);
Assert.That(whitelistSer.IsValid(invalidTag), Is.False); Assert.That(whitelistSer.IsValid(invalidTag), Is.False);
}); });
await pairTracker.CleanReturnAsync();
} }
} }
} }

9
Content.IntegrationTests/Tests/VendingMachineTest.cs
View File

@@ -8,14 +8,15 @@ namespace Content.IntegrationTests.Tests
{ {
[TestFixture] [TestFixture]
[TestOf(typeof(VendingMachineInventoryPrototype))] [TestOf(typeof(VendingMachineInventoryPrototype))]
public sealed class VendingMachineTest : ContentIntegrationTest public sealed class VendingMachineTest
{ {
[Test] [Test]
public async Task Test() public async Task Test()
{ {
var server = StartServer(); await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{NoClient = true});
var server = pairTracker.Pair.Server;
server.Assert(() => await server.WaitAssertion(() =>
{ {
var prototypeManager = IoCManager.Resolve<IPrototypeManager>(); var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
foreach (var vendorProto in prototypeManager.EnumeratePrototypes<VendingMachineInventoryPrototype>()) foreach (var vendorProto in prototypeManager.EnumeratePrototypes<VendingMachineInventoryPrototype>())
@@ -34,7 +35,7 @@ namespace Content.IntegrationTests.Tests
} }
}); });
await server.WaitIdleAsync(); await pairTracker.CleanReturnAsync();
} }
} }
} }

37
Content.MapRenderer/Painters/MapPainter.cs
View File

@@ -20,39 +20,16 @@ using SpriteComponent = Robust.Server.GameObjects.SpriteComponent;
namespace Content.MapRenderer.Painters namespace Content.MapRenderer.Painters
{ {
public sealed class MapPainter : ContentIntegrationTest public sealed class MapPainter
{ {
public async IAsyncEnumerable<Image> Paint(string map) public async IAsyncEnumerable<Image> Paint(string map)
{ {
var stopwatch = new Stopwatch(); var stopwatch = new Stopwatch();
stopwatch.Start(); stopwatch.Start();
var clientOptions = new ClientContentIntegrationOption await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings(){ Map = map});
{ var server = pairTracker.Pair.Server;
CVarOverrides = var client = pairTracker.Pair.Client;
{
[CVars.NetPVS.Name] = "false"
},
Pool = false,
FailureLogLevel = LogLevel.Fatal
};
var serverOptions = new ServerContentIntegrationOption
{
CVarOverrides =
{
[CCVars.GameMap.Name] = map,
[CVars.NetPVS.Name] = "false"
},
Pool = false,
FailureLogLevel = LogLevel.Fatal
};
var (client, server) = await StartConnectedServerClientPair(clientOptions, serverOptions);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
await RunTicksSync(client, server, 10);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
Console.WriteLine($"Loaded client and server in {(int) stopwatch.Elapsed.TotalMilliseconds} ms"); Console.WriteLine($"Loaded client and server in {(int) stopwatch.Elapsed.TotalMilliseconds} ms");
@@ -80,7 +57,7 @@ namespace Content.MapRenderer.Painters
} }
}); });
await RunTicksSync(client, server, 10); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
var sMapManager = server.ResolveDependency<IMapManager>(); var sMapManager = server.ResolveDependency<IMapManager>();
@@ -106,7 +83,7 @@ namespace Content.MapRenderer.Painters
} }
}); });
await RunTicksSync(client, server, 10); await PoolManager.RunTicksSync(pairTracker.Pair, 10);
await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync());
foreach (var grid in grids) foreach (var grid in grids)
@@ -147,7 +124,7 @@ namespace Content.MapRenderer.Painters
// We don't care if it fails as we have already saved the images. // We don't care if it fails as we have already saved the images.
try try
{ {
await OneTimeTearDown(); await pairTracker.CleanReturnAsync();
} }
catch catch
{ {

2
Content.Server/Station/Systems/StationJobsSystem.Roundstart.cs
View File

@@ -53,6 +53,8 @@ public sealed partial class StationJobsSystem
{ {
DebugTools.Assert(stations.Count > 0); DebugTools.Assert(stations.Count > 0);
InitializeRoundStart();
if (profiles.Count == 0) if (profiles.Count == 0)
return new Dictionary<NetUserId, (string, EntityUid)>(); return new Dictionary<NetUserId, (string, EntityUid)>();

2
Content.Server/Station/Systems/StationJobsSystem.cs
View File

@@ -32,8 +32,6 @@ public sealed partial class StationJobsSystem : EntitySystem
SubscribeLocalEvent<StationJobsComponent, ComponentShutdown>(OnStationDeletion); SubscribeLocalEvent<StationJobsComponent, ComponentShutdown>(OnStationDeletion);
SubscribeLocalEvent<PlayerJoinedLobbyEvent>(OnPlayerJoinedLobby); SubscribeLocalEvent<PlayerJoinedLobbyEvent>(OnPlayerJoinedLobby);
_configurationManager.OnValueChanged(CCVars.GameDisallowLateJoins, _ => UpdateJobsAvailable(), true); _configurationManager.OnValueChanged(CCVars.GameDisallowLateJoins, _ => UpdateJobsAvailable(), true);
InitializeRoundStart();
} }
public override void Update(float _) public override void Update(float _)

1
Content.Server/StationEvents/Events/BureaucraticError.cs
View File

@@ -26,6 +26,7 @@ public sealed class BureaucraticError : StationEvent
base.Startup(); base.Startup();
var stationSystem = EntitySystem.Get<StationSystem>(); var stationSystem = EntitySystem.Get<StationSystem>();
var stationJobsSystem = EntitySystem.Get<StationJobsSystem>(); var stationJobsSystem = EntitySystem.Get<StationJobsSystem>();
if (stationSystem.Stations.Count == 0) return; // No stations
var chosenStation = _random.Pick(stationSystem.Stations.ToList()); var chosenStation = _random.Pick(stationSystem.Stations.ToList());
var jobList = stationJobsSystem.GetJobs(chosenStation).Keys.ToList(); var jobList = stationJobsSystem.GetJobs(chosenStation).Keys.ToList();

32
Content.YAMLLinter/Program.cs
View File

@@ -11,7 +11,7 @@ using Robust.Shared.Utility;
namespace Content.YAMLLinter namespace Content.YAMLLinter
{ {
internal class Program : ContentIntegrationTest internal class Program
{ {
private static int Main(string[] args) private static int Main(string[] args)
{ {
@@ -45,45 +45,36 @@ namespace Content.YAMLLinter
private async Task<Dictionary<string, HashSet<ErrorNode>>> ValidateClient() private async Task<Dictionary<string, HashSet<ErrorNode>>> ValidateClient()
{ {
var client = StartClient(new ClientContentIntegrationOption() await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{DummyTicker = true, Disconnected = true});
{ var client = pairTracker.Pair.Client;
FailureLogLevel = null,
});
await client.WaitIdleAsync();
var cPrototypeManager = client.ResolveDependency<IPrototypeManager>(); var cPrototypeManager = client.ResolveDependency<IPrototypeManager>();
var clientErrors = new Dictionary<string, HashSet<ErrorNode>>(); var clientErrors = new Dictionary<string, HashSet<ErrorNode>>();
await client.WaitAssertion(() => await client.WaitPost(() =>
{ {
clientErrors = cPrototypeManager.ValidateDirectory(new ResourcePath("/Prototypes")); clientErrors = cPrototypeManager.ValidateDirectory(new ResourcePath("/Prototypes"));
}); });
client.Stop(); await pairTracker.CleanReturnAsync();
return clientErrors; return clientErrors;
} }
private async Task<Dictionary<string, HashSet<ErrorNode>>> ValidateServer() private async Task<Dictionary<string, HashSet<ErrorNode>>> ValidateServer()
{ {
var server = StartServer(new ServerContentIntegrationOption() await using var pairTracker = await PoolManager.GetServerClient(new PoolSettings{DummyTicker = true, Disconnected = true});
{ var server = pairTracker.Pair.Server;
FailureLogLevel = null,
CVarOverrides = { {CCVars.GameDummyTicker.Name, "true"} }
});
await server.WaitIdleAsync();
var sPrototypeManager = server.ResolveDependency<IPrototypeManager>(); var sPrototypeManager = server.ResolveDependency<IPrototypeManager>();
var serverErrors = new Dictionary<string, HashSet<ErrorNode>>(); var serverErrors = new Dictionary<string, HashSet<ErrorNode>>();
await server.WaitAssertion(() => await server.WaitPost(() =>
{ {
serverErrors = sPrototypeManager.ValidateDirectory(new ResourcePath("/Prototypes")); serverErrors = sPrototypeManager.ValidateDirectory(new ResourcePath("/Prototypes"));
}); });
server.Stop(); await pairTracker.CleanReturnAsync();
return serverErrors; return serverErrors;
} }
@@ -92,9 +83,8 @@ namespace Content.YAMLLinter
{ {
var allErrors = new Dictionary<string, HashSet<ErrorNode>>(); var allErrors = new Dictionary<string, HashSet<ErrorNode>>();
var tasks = await Task.WhenAll(ValidateClient(), ValidateServer()); var serverErrors = await ValidateServer();
var clientErrors = tasks[0]; var clientErrors = await ValidateClient();
var serverErrors = tasks[1];
foreach (var (key, val) in serverErrors) foreach (var (key, val) in serverErrors)
{ {