h-school/tests/HSchool.Content.Tests/BehaviorDefTests.cs

namespace HSchool.Content.Tests;

public class BehaviorDefTests
{
    private readonly CatalogLoader _loader = new();

    [Theory]
    [InlineData("dutyLessonWeight")]
    [InlineData("dutyTravelWeight")]
    [InlineData("needWeightAtZero")]
    [InlineData("lunchWeight")]
    public void NegativeGoalWeight_FailsTheCatalog(string field)
    {
        var error = Assert.Throws<ContentLoadException>(() => _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    $$"""{ "defName": "Behavior", "{{field}}": -1 }"""),
            ]));

        Assert.Contains("negative", error.Message, StringComparison.OrdinalIgnoreCase);
        Assert.Contains("Behavior", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void LunchHeavierThanLesson_WarnsAndStillLoads()
    {
        var log = new RecordingLog();
        var catalog = _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "dutyLessonWeight": 10, "lunchWeight": 11 }"""),
            ],
            log);

        Assert.NotNull(catalog.BehaviorRules);
        Assert.Equal(11f, catalog.BehaviorRules.LunchWeight);
        Assert.Contains(
            log.Warnings,
            warning => warning.Contains("lunchWeight", StringComparison.Ordinal)
                && warning.Contains("dutyLessonWeight", StringComparison.Ordinal));
    }

    [Fact]
    public void NegativeCarryMass_FailsTheCatalog()
    {
        var error = Assert.Throws<ContentLoadException>(() => _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "carryMassBase": -1 }"""),
            ]));

        Assert.Contains("carry mass", error.Message, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public void MissingLessonNoTextbookFactor_DefaultsToHalf()
    {
        var catalog = _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "needThreshold": 0.35, "lessonSkillPerHour": 0.05, "commuteSlackMin": 0, "commuteSlackMax": 6, "switchMargin": 0.15 }"""),
            ]);

        Assert.NotNull(catalog.BehaviorRules);
        Assert.Equal(0.5f, catalog.BehaviorRules.LessonNoTextbookFactor);
    }

    [Fact]
    public void LessonNoTextbookFactor_OutOfRange_FailsTheCatalog()
    {
        var error = Assert.Throws<ContentLoadException>(() => _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "lessonNoTextbookFactor": 1.5 }"""),
            ]));

        Assert.Contains("lessonNoTextbookFactor", error.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void MissingCommuteWeatherMinutes_DefaultToZero()
    {
        var catalog = _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "needThreshold": 0.35, "lessonSkillPerHour": 0.05, "commuteSlackMin": 0, "commuteSlackMax": 6, "switchMargin": 0.15 }"""),
            ]);

        Assert.NotNull(catalog.BehaviorRules);
        Assert.Equal(0, catalog.BehaviorRules.CommuteRainMinutes);
        Assert.Equal(0, catalog.BehaviorRules.CommuteSnowMinutes);
        Assert.Equal(0.4f, catalog.BehaviorRules.LessonWhisperSkillFactor);
        Assert.Equal(0.4f, catalog.BehaviorRules.WhisperCatchChance);
    }

    [Theory]
    [InlineData("commuteRainMinutes")]
    [InlineData("commuteSnowMinutes")]
    public void NegativeCommuteWeatherMinutes_FailsTheCatalog(string field)
    {
        var error = Assert.Throws<ContentLoadException>(() => _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    $$"""{ "defName": "Behavior", "{{field}}": -1 }"""),
            ]));

        Assert.Contains("cannot be negative", error.Message, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public void NegativeApparelWear_FailsTheCatalog()
    {
        var error = Assert.Throws<ContentLoadException>(() => _loader.Load(
            [CatalogLoader.CorePackId],
            [
                PackDocuments.Def(
                    CatalogLoader.CorePackId,
                    "behavior",
                    "rules",
                    """{ "defName": "Behavior", "apparelWearPerHour": -0.1 }"""),
            ]));

        Assert.Contains("apparelWearPerHour", error.Message, StringComparison.Ordinal);
    }
}