chapter-organizer/Tests/Validation/ValidationConfigurationTests.cs

using Core.Entities;
using Core.Validation;
using System.Text.Json;

namespace Tests.Validation;

[TestFixture]
public class ValidationConfigurationTests
{
    [Test]
    public void Default_ReturnsExpectedValues()
    {
        // Arrange & Act
        var config = ValidationConfiguration.Default;

        // Assert
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(2));
        Assert.That(config.MaxRecommendedEvents, Is.EqualTo(4));
        Assert.That(config.MinCriticalEvents, Is.EqualTo(1));
        Assert.That(config.MaxCriticalEvents, Is.EqualTo(6));
        Assert.That(config.MaxRegionalEvents, Is.EqualTo(3));
        Assert.That(config.RequireRegionalEvent, Is.True);
        Assert.That(config.RequireOnSiteActivity, Is.True);
        Assert.That(config.RequireIndividualEvent, Is.False);
        Assert.That(config.RequireTeamCaptain, Is.True);
        Assert.That(config.NoRegionalEventSeverity, Is.EqualTo(ValidationSeverity.Warning));
        Assert.That(config.EventCountSeverity, Is.EqualTo(ValidationSeverity.Warning));
        Assert.That(config.MissingCaptainSeverity, Is.EqualTo(ValidationSeverity.Warning));
        Assert.That(config.TooManyRegionalEventsSeverity, Is.EqualTo(ValidationSeverity.Warning));
    }

    [Test]
    public void FromAssignmentParameters_CreatesCorrectConfiguration()
    {
        // Arrange
        var parameters = new AssignmentParameters(
            effortLowerBound: 5,
            effortUpperBound: 8,
            eventsLowerBound: 2,
            eventsUpperBound: 4,
            requireRegional: true,
            requireOnSite: false
        );

        // Act
        var config = ValidationConfiguration.FromAssignmentParameters(parameters);

        // Assert
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(2));
        Assert.That(config.MaxRecommendedEvents, Is.EqualTo(4));
        Assert.That(config.RequireRegionalEvent, Is.True);
        Assert.That(config.RequireOnSiteActivity, Is.False);
        Assert.That(config.MinCriticalEvents, Is.EqualTo(1));
        Assert.That(config.MaxCriticalEvents, Is.EqualTo(6));
        Assert.That(config.RequireTeamCaptain, Is.True);
    }

    [Test]
    public void FromJson_ValidJson_ReturnsConfiguration()
    {
        // Arrange
        var json = @"{
            ""MinRecommendedEvents"": 3,
            ""MaxRecommendedEvents"": 5,
            ""RequireRegionalEvent"": false,
            ""NoRegionalEventSeverity"": ""Error""
        }";

        // Act
        var config = ValidationConfiguration.FromJson(json);

        // Assert
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(3));
        Assert.That(config.MaxRecommendedEvents, Is.EqualTo(5));
        Assert.That(config.RequireRegionalEvent, Is.False);
        Assert.That(config.NoRegionalEventSeverity, Is.EqualTo(ValidationSeverity.Error));
    }

    [Test]
    public void FromJson_InvalidJson_ReturnsDefault()
    {
        // Arrange
        var invalidJson = "{ invalid json }";

        // Act
        var config = ValidationConfiguration.FromJson(invalidJson);

        // Assert - should return Default config on error
        Assert.That(config, Is.Not.Null);
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(ValidationConfiguration.Default.MinRecommendedEvents));
    }

    [Test]
    public async Task LoadFromFileAsync_NonExistentFile_ReturnsDefault()
    {
        // Arrange
        var nonExistentPath = Path.Combine(Path.GetTempPath(), $"non_existent_{Guid.NewGuid()}.json");

        // Act
        var config = await ValidationConfiguration.LoadFromFileAsync(nonExistentPath);

        // Assert
        Assert.That(config, Is.Not.Null);
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(ValidationConfiguration.Default.MinRecommendedEvents));
    }

    [Test]
    public async Task SaveToFileAsync_And_LoadFromFileAsync_RoundTrip()
    {
        // Arrange
        var tempPath = Path.Combine(Path.GetTempPath(), $"test_config_{Guid.NewGuid()}.json");
        var originalConfig = new ValidationConfiguration
        {
            MinRecommendedEvents = 3,
            MaxRecommendedEvents = 5,
            RequireRegionalEvent = false,
            NoRegionalEventSeverity = ValidationSeverity.Error,
            MaxRegionalEvents = 2
        };

        try
        {
            // Act
            await originalConfig.SaveToFileAsync(tempPath);
            var loadedConfig = await ValidationConfiguration.LoadFromFileAsync(tempPath);

            // Assert
            Assert.That(loadedConfig.MinRecommendedEvents, Is.EqualTo(3));
            Assert.That(loadedConfig.MaxRecommendedEvents, Is.EqualTo(5));
            Assert.That(loadedConfig.RequireRegionalEvent, Is.False);
            Assert.That(loadedConfig.NoRegionalEventSeverity, Is.EqualTo(ValidationSeverity.Error));
            Assert.That(loadedConfig.MaxRegionalEvents, Is.EqualTo(2));
        }
        finally
        {
            // Cleanup
            if (File.Exists(tempPath))
                File.Delete(tempPath);
        }
    }

    [Test]
    public async Task SaveToFileAsync_CreatesReadableJson()
    {
        // Arrange
        var tempPath = Path.Combine(Path.GetTempPath(), $"test_config_{Guid.NewGuid()}.json");
        var config = new ValidationConfiguration
        {
            MinRecommendedEvents = 2,
            MaxRecommendedEvents = 4
        };

        try
        {
            // Act
            await config.SaveToFileAsync(tempPath);
            var jsonContent = await File.ReadAllTextAsync(tempPath);

            // Assert
            Assert.That(jsonContent, Does.Contain("MinRecommendedEvents"));
            Assert.That(jsonContent, Does.Contain("MaxRecommendedEvents"));

            // Verify it's valid JSON
            var doc = JsonDocument.Parse(jsonContent);
            Assert.That(doc, Is.Not.Null);
        }
        finally
        {
            // Cleanup
            if (File.Exists(tempPath))
                File.Delete(tempPath);
        }
    }

    [Test]
    public void ValidationConfiguration_CanBeModified()
    {
        // Arrange
        var config = ValidationConfiguration.Default;

        // Act
        config.MinRecommendedEvents = 5;
        config.RequireRegionalEvent = false;
        config.NoRegionalEventSeverity = ValidationSeverity.Error;

        // Assert
        Assert.That(config.MinRecommendedEvents, Is.EqualTo(5));
        Assert.That(config.RequireRegionalEvent, Is.False);
        Assert.That(config.NoRegionalEventSeverity, Is.EqualTo(ValidationSeverity.Error));
    }

    [Test]
    public void ValidationConfiguration_AllPropertiesSerializable()
    {
        // Arrange
        var config = new ValidationConfiguration
        {
            MinRecommendedEvents = 1,
            MaxRecommendedEvents = 2,
            MinCriticalEvents = 3,
            MaxCriticalEvents = 4,
            MaxRegionalEvents = 5,
            RequireRegionalEvent = true,
            RequireOnSiteActivity = false,
            RequireIndividualEvent = true,
            RequireTeamCaptain = false,
            NoRegionalEventSeverity = ValidationSeverity.Error,
            NoOnSiteActivitySeverity = ValidationSeverity.Warning,
            NoIndividualEventSeverity = ValidationSeverity.Error,
            TeamSizeSeverity = ValidationSeverity.Warning,
            EventCountSeverity = ValidationSeverity.Error,
            MissingCaptainSeverity = ValidationSeverity.Warning,
            TooManyRegionalEventsSeverity = ValidationSeverity.Error
        };

        // Act
        var json = JsonSerializer.Serialize(config);
        var deserialized = JsonSerializer.Deserialize<ValidationConfiguration>(json);

        // Assert
        Assert.That(deserialized, Is.Not.Null);
        Assert.That(deserialized!.MinRecommendedEvents, Is.EqualTo(config.MinRecommendedEvents));
        Assert.That(deserialized.MaxRecommendedEvents, Is.EqualTo(config.MaxRecommendedEvents));
        Assert.That(deserialized.RequireRegionalEvent, Is.EqualTo(config.RequireRegionalEvent));
        Assert.That(deserialized.NoRegionalEventSeverity, Is.EqualTo(config.NoRegionalEventSeverity));
        Assert.That(deserialized.MaxRegionalEvents, Is.EqualTo(config.MaxRegionalEvents));
        Assert.That(deserialized.TooManyRegionalEventsSeverity, Is.EqualTo(config.TooManyRegionalEventsSeverity));
    }
}