Inline TryAllReactionsTest (#44588)

This commit is contained in:
ArtisticRoomba 2026-07-13 00:37:01 -07:00 • committed by GitHub
parent 0c0b7381fc
commit f401a44b91
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -2,21 +2,21 @@ using Content.Shared.Chemistry.Reaction;
using Content.Shared.Chemistry.Components;
using Robust.Shared.GameObjects;
using Robust.Shared.Map;
using Robust.Shared.Prototypes;
using Robust.Shared.Utility;
using System.Linq;
using Content.IntegrationTests.Fixtures;
using Content.IntegrationTests.Fixtures.Attributes;
using Content.IntegrationTests.Utility;
using Content.Shared.Chemistry.EntitySystems;
namespace Content.IntegrationTests.Tests.Chemistry
namespace Content.IntegrationTests.Tests.Chemistry;
[TestFixture]
[TestOf(typeof(ReactionPrototype))]
public sealed class TryAllReactionsTest : GameTest
{
[TestFixture]
[TestOf(typeof(ReactionPrototype))]
public sealed class TryAllReactionsTest : GameTest
{
[TestPrototypes]
private const string Prototypes = @"
[TestPrototypes]
private const string Prototypes = @"
- type: entity
id: TestSolutionContainer
components:
@ -25,115 +25,124 @@ namespace Content.IntegrationTests.Tests.Chemistry
solution:
maxVol: 120";
private static string[] _reactions = GameDataScrounger.PrototypesOfKind<ReactionPrototype>();
private static readonly string[] Reactions = GameDataScrounger.PrototypesOfKind<ReactionPrototype>();
[Test]
[TestCaseSource(nameof(_reactions))]
[TestOf(typeof(ReactionPrototype))]
[Description("Tries an individual reaction to see if it succeeds.")]
public async Task TryReaction(string reaction)
[SidedDependency(Side.Server)] private readonly SharedSolutionContainerSystem _solutionContainerSystem = default!;
[Test]
[TestOf(typeof(ReactionPrototype))]
[Description("Tries an individual reaction to see if it succeeds.")]
public async Task TryReaction()
{
var testMap = await Pair.CreateTestMap();
var coordinates = testMap.GridCoords;
// they call me a bird the way i be nesting
try
{
var pair = Pair;
var server = pair.Server;
var entityManager = server.ResolveDependency<IEntityManager>();
var prototypeManager = server.ResolveDependency<IPrototypeManager>();
var testMap = await pair.CreateTestMap();
var coordinates = testMap.GridCoords;
var solutionContainerSystem = entityManager.System<SharedSolutionContainerSystem>();
var reactionPrototype = prototypeManager.Index<ReactionPrototype>(reaction);
EntityUid beaker = default;
Solution solution = null;
Entity<SolutionComponent>? solutionEnt = default!;
await server.WaitAssertion(() =>
{
beaker = entityManager.SpawnEntity("TestSolutionContainer", coordinates);
Assert.That(solutionContainerSystem
.TryGetSolution(beaker, "beaker", out solutionEnt, out solution));
solutionContainerSystem.SetCanReact(solutionEnt!.Value, false);
foreach (var (id, reactant) in reactionPrototype.Reactants)
{
#pragma warning disable NUnit2045
Assert.That(solutionContainerSystem
.TryAddReagent(solutionEnt.Value,
id,
reactant.Amount,
out var quantity,
reactionPrototype.MinimumTemperature));
Assert.That(reactant.Amount, Is.EqualTo(quantity));
#pragma warning restore NUnit2045
}
//Get all possible reactions with the current reagents
var possibleReactions = prototypeManager.EnumeratePrototypes<ReactionPrototype>()
.Where(x => x.Reactants.All(id => solution.Contents.Any(s => s.Reagent.Prototype == id.Key)))
.ToList();
//Check if the reaction is the first to occur when heated
foreach (var possibleReaction in possibleReactions.OrderBy(r => r.MinimumTemperature))
{
if (possibleReaction.Priority >= reactionPrototype.Priority &&
possibleReaction.MinimumTemperature < reactionPrototype.MinimumTemperature &&
possibleReaction.MixingCategories == reactionPrototype.MixingCategories)
{
Assert.Fail(
$"The {possibleReaction.ID} reaction may occur before {reactionPrototype.ID} when heated.");
}
}
//Check if the reaction is the first to occur when freezing
foreach (var possibleReaction in possibleReactions.OrderBy(r => r.MaximumTemperature))
{
if (possibleReaction.Priority >= reactionPrototype.Priority &&
possibleReaction.MaximumTemperature > reactionPrototype.MaximumTemperature &&
possibleReaction.MixingCategories == reactionPrototype.MixingCategories)
{
Assert.Fail(
$"The {possibleReaction.ID} reaction may occur before {reactionPrototype.ID} when freezing.");
}
}
//Now safe set the temperature and mix the reagents
solutionContainerSystem.SetTemperature(solutionEnt.Value, reactionPrototype.MinimumTemperature);
solutionContainerSystem.SetCanReact(solutionEnt.Value, true);
if (reactionPrototype.MixingCategories != null)
{
var dummyEntity = entityManager.SpawnEntity(null, MapCoordinates.Nullspace);
var mixerComponent = entityManager.AddComponent<ReactionMixerComponent>(dummyEntity);
mixerComponent.ReactionTypes = reactionPrototype.MixingCategories;
solutionContainerSystem.UpdateChemicals(solutionEnt.Value, true, mixerComponent);
}
});
await server.WaitIdleAsync();
await server.WaitAssertion(() =>
foreach (var reaction in Reactions)
{
//you just got linq'd fool
//(i'm sorry)
var foundProductsMap = reactionPrototype.Products
.Concat(reactionPrototype.Reactants
.Where(x => x.Value.Catalyst)
.ToDictionary(x => x.Key, x => x.Value.Amount)
)
.ToDictionary(x => x, _ => false);
var reactionPrototype = SProtoMan.Index<ReactionPrototype>(reaction);
foreach (var (reagent, quantity) in solution.Contents)
EntityUid beaker = default;
Solution solution = null;
try
{
Assert.That(foundProductsMap.TryFirstOrNull(
x => x.Key.Key == reagent.Prototype && x.Key.Value == quantity,
out var foundProduct));
foundProductsMap[foundProduct!.Value.Key] = true;
await Pair.Server.WaitAssertion(() =>
{
beaker = SEntMan.SpawnEntity("TestSolutionContainer", coordinates);
Assert.That(_solutionContainerSystem
.TryGetSolution(beaker, "beaker", out var solutionEnt, out solution));
_solutionContainerSystem.SetCanReact(solutionEnt!.Value, false);
foreach (var (id, reactant) in reactionPrototype.Reactants)
{
Assert.That(_solutionContainerSystem
.TryAddReagent(solutionEnt.Value,
id,
reactant.Amount,
out var quantity,
reactionPrototype.MinimumTemperature));
Assert.That(reactant.Amount, Is.EqualTo(quantity));
}
//Get all possible reactions with the current reagents
var possibleReactions = SProtoMan.EnumeratePrototypes<ReactionPrototype>()
.Where(x => x.Reactants.All(id =>
solution.Contents.Any(s => s.Reagent.Prototype == id.Key)))
.ToList();
//Check if the reaction is the first to occur when heated
foreach (var possibleReaction in possibleReactions.OrderBy(r => r.MinimumTemperature))
{
if (possibleReaction.Priority >= reactionPrototype.Priority &&
possibleReaction.MinimumTemperature < reactionPrototype.MinimumTemperature &&
possibleReaction.MixingCategories == reactionPrototype.MixingCategories)
{
Assert.Fail(
$"The {possibleReaction.ID} reaction may occur before {reactionPrototype.ID} when heated.");
}
}
//Check if the reaction is the first to occur when freezing
foreach (var possibleReaction in possibleReactions.OrderBy(r => r.MaximumTemperature))
{
if (possibleReaction.Priority >= reactionPrototype.Priority &&
possibleReaction.MaximumTemperature > reactionPrototype.MaximumTemperature &&
possibleReaction.MixingCategories == reactionPrototype.MixingCategories)
{
Assert.Fail(
$"The {possibleReaction.ID} reaction may occur before {reactionPrototype.ID} when freezing.");
}
}
//Now safe set the temperature and mix the reagents
_solutionContainerSystem.SetTemperature(solutionEnt.Value,
reactionPrototype.MinimumTemperature);
_solutionContainerSystem.SetCanReact(solutionEnt.Value, true);
if (reactionPrototype.MixingCategories != null)
{
var dummyEntity = SEntMan.SpawnEntity(null, MapCoordinates.Nullspace);
var mixerComponent = SEntMan.AddComponent<ReactionMixerComponent>(dummyEntity);
mixerComponent.ReactionTypes = reactionPrototype.MixingCategories;
_solutionContainerSystem.UpdateChemicals(solutionEnt.Value, true, mixerComponent);
}
});
await Pair.Server.WaitIdleAsync();
await Pair.Server.WaitAssertion(() =>
{
//you just got linq'd fool
//(i'm sorry)
var foundProductsMap = reactionPrototype.Products
.Concat(reactionPrototype.Reactants
.Where(x => x.Value.Catalyst)
.ToDictionary(x => x.Key, x => x.Value.Amount)
)
.ToDictionary(x => x, _ => false);
foreach (var (reagent, quantity) in solution.Contents)
{
Assert.That(foundProductsMap.TryFirstOrNull(
x => x.Key.Key == reagent.Prototype && x.Key.Value == quantity,
out var foundProduct));
foundProductsMap[foundProduct!.Value.Key] = true;
}
Assert.That(foundProductsMap.All(x => x.Value));
});
}
Assert.That(foundProductsMap.All(x => x.Value));
server.EntMan.DeleteEntity(beaker);
});
finally
{
await Server.WaitPost(() => SEntMan.DeleteEntity(beaker));
}
}
}
finally
{
await Server.WaitPost(() => SEntMan.DeleteEntity(testMap.MapUid));
}
}
}