182 lines
8.4 KiB
C#
182 lines
8.4 KiB
C#
using System;
|
|
using System.Linq;
|
|
using GameCult.Caching;
|
|
using Xunit;
|
|
|
|
// A commodity's recipe takes roles as well as named commodities (aetheria-living-world, cut recipe-role-inputs): RecipeData.RoleInputs,
|
|
// the one reader of role slots (Recipes.RoleInputsOf), and the checks reading a role input as any commodity that fills it.
|
|
public sealed class RecipeRoleInputTests
|
|
{
|
|
private static string Iron => EconomyFixture.Key("iron");
|
|
|
|
// hematite and ilmenite are raw ores filling iron-ore (ilmenite also titanium-ore); iron takes 2 iron-ore.
|
|
private static EconomyFixture Smelter()
|
|
{
|
|
var f = new EconomyFixture();
|
|
f.Good("hematite", fills: new[] { "iron-ore" });
|
|
f.Good("ilmenite", fills: new[] { "iron-ore", "titanium-ore" });
|
|
f.Good("iron", roleInputs: new[] { ("iron-ore", 2) }, fills: new[] { "Plate" });
|
|
f.Gear("laser", new[] { ("Plate", 2) });
|
|
return f;
|
|
}
|
|
|
|
private static string[] Records(System.Collections.Generic.IEnumerable<EconomyFault> faults, string invariant) =>
|
|
faults.Where(x => x.Invariant == invariant).Select(x => x.Record).ToArray();
|
|
|
|
[Fact]
|
|
public void ShippedRecipesReadAnEmptyRoleInputList()
|
|
{
|
|
using var cache = AetheriaStores.Open(TestCatalog.Repo, registry: TestCatalog.Registry());
|
|
var recipes = cache.GetAll<RecipeData>().ToArray();
|
|
Assert.NotEmpty(recipes);
|
|
Assert.All(recipes, r => { Assert.NotNull(r.RoleInputs); Assert.Empty(r.RoleInputs); });
|
|
}
|
|
|
|
[Fact]
|
|
public void ARoleInputSurvivesReopen()
|
|
{
|
|
using var f = Smelter();
|
|
f.Reopen();
|
|
var role = Assert.Single(f.Cache.Get<RecipeData>(RecipeData.KeyOf(new CultRecordKey(Iron))).RoleInputs);
|
|
Assert.Equal(("iron-ore", 2), (role.Name, role.Count));
|
|
}
|
|
|
|
[Fact]
|
|
public void RoleInputsOfReadsTheDesignOrTheRecipe()
|
|
{
|
|
using var f = Smelter();
|
|
var laser = Assert.Single(Recipes.RoleInputsOf(f.Cache, f.Cache.Get<RecipeData>(RecipeData.KeyOf(new CultRecordKey("gear:laser")))));
|
|
Assert.Equal(("Plate", 2), (laser.Name, laser.Count));
|
|
var ironRecipe = f.Cache.Get<RecipeData>(RecipeData.KeyOf(new CultRecordKey(Iron)));
|
|
var ore = Assert.Single(Recipes.RoleInputsOf(f.Cache, ironRecipe));
|
|
Assert.Equal(("iron-ore", 2), (ore.Name, ore.Count));
|
|
Assert.False(Recipes.IsRaw(f.Cache, ironRecipe));
|
|
Assert.True(Recipes.IsRaw(f.Cache, f.Cache.Get<RecipeData>(RecipeData.KeyOf(new CultRecordKey(EconomyFixture.Key("hematite"))))));
|
|
Assert.False(Recipes.IsConsumerGood(f.Cache, ironRecipe));
|
|
}
|
|
|
|
[Fact]
|
|
public void ANullListElsewhereInARecipeLeavesItsRoleInputsToTheRules()
|
|
{
|
|
using var f = Smelter();
|
|
Assert.Empty(EconomyChecks.Check(f.Cache).Faults.Where(x => x.Invariant != EconomyChecks.LRecipe));
|
|
f.EditRecipe(Iron, r => r.Upkeep = null);
|
|
Assert.Empty(EconomyChecks.Check(f.Cache).Faults.Where(x => x.Invariant != EconomyChecks.LRecipe));
|
|
}
|
|
|
|
[Fact]
|
|
public void DepthReadsARoleInputAsItsShallowestFiller()
|
|
{
|
|
using var f = new EconomyFixture();
|
|
f.Good("hematite", fills: new[] { "iron-ore" });
|
|
f.Good("grit");
|
|
f.Good("pulp", inputs: new[] { ("grit", 1) });
|
|
f.Good("sludge", inputs: new[] { ("pulp", 1) }, fills: new[] { "iron-ore" });
|
|
f.Good("iron", roleInputs: new[] { ("iron-ore", 1) });
|
|
Assert.Equal(1, EconomyChecks.Deep(f.Cache)[Iron]);
|
|
f.EditRecipe(EconomyFixture.Key("hematite"), r => r.Fills.Clear());
|
|
Assert.Equal(3, EconomyChecks.Deep(f.Cache)[Iron]);
|
|
f.EditRecipe(EconomyFixture.Key("sludge"), r => r.Fills.Clear());
|
|
Assert.Null(EconomyChecks.Deep(f.Cache)[Iron]);
|
|
}
|
|
|
|
[Fact]
|
|
public void SourceComesThroughAnyFillerOfARoleInput()
|
|
{
|
|
using var f = new EconomyFixture();
|
|
f.Good("hematite", fills: new[] { "iron-ore" });
|
|
f.Good("loopa", inputs: new[] { ("loopb", 1) }, fills: new[] { "iron-ore" });
|
|
f.Good("loopb", inputs: new[] { ("loopa", 1) });
|
|
f.Good("iron", roleInputs: new[] { ("iron-ore", 1) });
|
|
bool NoSource() => EconomyChecks.SourceSink(f.Cache).Any(x => x.Record == "recipe:" + Iron && x.Message.Contains("no source"));
|
|
Assert.False(NoSource());
|
|
f.EditRecipe(EconomyFixture.Key("hematite"), r => r.Fills.Clear());
|
|
Assert.True(NoSource());
|
|
}
|
|
|
|
[Fact]
|
|
public void AGoodFillingOnlyARoleInputHasASink()
|
|
{
|
|
using var f = Smelter();
|
|
f.Good("titanium", roleInputs: new[] { ("titanium-ore", 1) });
|
|
bool NoSink() => EconomyChecks.SourceSink(f.Cache).Any(x => x.Record == "recipe:" + EconomyFixture.Key("ilmenite") && x.Message.Contains("no sink"));
|
|
Assert.False(NoSink());
|
|
f.EditRecipe(Iron, r => r.RoleInputs.Clear());
|
|
f.EditRecipe(EconomyFixture.Key("titanium"), r => r.RoleInputs.Clear());
|
|
Assert.True(NoSink());
|
|
}
|
|
|
|
[Fact]
|
|
public void ProductiveReadsTheWorstFillerOfARoleInput()
|
|
{
|
|
using var f = new EconomyFixture();
|
|
f.Good("hematite", fills: new[] { "iron-ore" });
|
|
f.Good("iron", roleInputs: new[] { ("iron-ore", 2) });
|
|
Assert.Empty(EconomyChecks.Productive(f.Cache));
|
|
f.Good("scrap", inputs: new[] { ("iron", 2) }, fills: new[] { "iron-ore" });
|
|
var fault = Assert.Single(EconomyChecks.Productive(f.Cache));
|
|
Assert.Contains("commodity:iron", fault.Message);
|
|
Assert.Contains("commodity:scrap", fault.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void ConsumerDemandWalksThroughARoleInput()
|
|
{
|
|
using var f = new EconomyFixture();
|
|
f.Good("rawx");
|
|
f.Good("acid", inputs: new[] { ("rawx", 1) }, fills: new[] { "reagent" });
|
|
f.Good("g1", roleInputs: new[] { ("reagent", 1) }, fills: new[] { "Barrel" });
|
|
f.Good("g2", roleInputs: new[] { ("reagent", 1) }, fills: new[] { "Plate" });
|
|
f.Gear("cannon", new[] { ("Barrel", 1) });
|
|
f.Hull("tug", HullType.Ship, new[] { ("Plate", 1) });
|
|
Assert.Equal(new[] { "recipe:" + EconomyFixture.Key("acid") }, Records(EconomyChecks.ConsumerDemand(f.Cache), EconomyChecks.LDemand));
|
|
f.Good("toaster", roles: new[] { ("Barrel", 1) });
|
|
Assert.Empty(EconomyChecks.ConsumerDemand(f.Cache));
|
|
}
|
|
|
|
private static EconomyFixture Casings(Action<EconomyFixture> design)
|
|
{
|
|
var f = EconomyFixture.Healthy();
|
|
f.Good("cap", inputs: new[] { ("ore", 1) }, fills: new[] { "Casing" });
|
|
f.Good("alloy", inputs: new[] { ("ore", 1) }, fills: new[] { "Casing", "Plate" });
|
|
design(f);
|
|
return f;
|
|
}
|
|
|
|
[Fact]
|
|
public void ADesignWithARecipeNamesItsRolesOfferedOrNot()
|
|
{
|
|
using var f = Casings(g => g.Gear("shell", new[] { ("Casing", 1) }, offered: false));
|
|
Assert.DoesNotContain(EconomyChecks.SourceSink(f.Cache), x => x.Record == "recipe:" + EconomyFixture.Key("cap") && x.Message.Contains("no sink"));
|
|
Assert.Equal(new[] { "recipe:" + EconomyFixture.Key("alloy") }, Records(EconomyChecks.ConsumerDemand(f.Cache), EconomyChecks.LDemand));
|
|
}
|
|
|
|
[Fact]
|
|
public void OfferedDesignsWithoutARecipeAreFaultedInKeyOrder()
|
|
{
|
|
using var f = EconomyFixture.Healthy();
|
|
f.Gear("zeta", new[] { ("Plate", 1) }, recipe: false);
|
|
f.Gear("alpha", new[] { ("Plate", 1) }, recipe: false);
|
|
Assert.Equal(new[] { "gear:alpha", "gear:zeta" }, EconomyChecks.Recipe(f.Cache).Select(x => x.Record));
|
|
}
|
|
|
|
[Fact]
|
|
public void AnOfferedDesignWithoutARecipeStillNamesItsRoles()
|
|
{
|
|
using (var offered = Casings(f => f.Gear("shell", new[] { ("Casing", 1) }, recipe: false)))
|
|
{
|
|
Assert.DoesNotContain(EconomyChecks.SourceSink(offered.Cache), x => x.Record == "recipe:" + EconomyFixture.Key("cap") && x.Message.Contains("no sink"));
|
|
Assert.Equal(new[] { "recipe:" + EconomyFixture.Key("alloy") }, Records(EconomyChecks.ConsumerDemand(offered.Cache), EconomyChecks.LDemand));
|
|
}
|
|
foreach (var design in new Action<EconomyFixture>[]
|
|
{
|
|
f => f.Gear("shell", new[] { ("Casing", 1) }, offered: false, recipe: false),
|
|
f => f.Hull("outpost", HullType.Station, new[] { ("Casing", 1) }, recipe: false)
|
|
})
|
|
using (var f = Casings(design))
|
|
{
|
|
Assert.Contains(EconomyChecks.SourceSink(f.Cache), x => x.Record == "recipe:" + EconomyFixture.Key("cap") && x.Message.Contains("no sink"));
|
|
Assert.Empty(EconomyChecks.ConsumerDemand(f.Cache));
|
|
}
|
|
}
|
|
}
|