jdescopingtool/NEW/tests/JdeScoping.ConfigManager.Tests/ViewModels/RegexTransformerViewModelTests.cs

using JdeScoping.ConfigManager.Models;
using JdeScoping.ConfigManager.ViewModels.PipelineSteps;

namespace JdeScoping.ConfigManager.Tests.ViewModels;

public class RegexTransformerViewModelTests
{
    [Fact]
    public void Constructor_FromModel_LoadsAllProperties()
    {
        // Arrange
        var model = new TransformerModel
        {
            Type = "Regex",
            ColumnName = "BatchID",
            Pattern = "^IIS_",
            Replacement = "",
            IgnoreCase = true,
            NonMatchBehavior = NonMatchBehavior.ReturnEmpty
        };

        // Act
        var vm = new RegexTransformerViewModel(model, () => { });

        // Assert
        Assert.Equal("BatchID", vm.ColumnName);
        Assert.Equal("^IIS_", vm.Pattern);
        Assert.Equal("", vm.Replacement);
        Assert.True(vm.IsFindReplaceMode);
        Assert.True(vm.IgnoreCase);
        Assert.Equal(NonMatchBehavior.ReturnEmpty, vm.NonMatchBehavior);
    }

    [Fact]
    public void Constructor_FromModel_MatchExtractMode_WhenReplacementNull()
    {
        // Arrange
        var model = new TransformerModel
        {
            Type = "Regex",
            ColumnName = "Code",
            Pattern = @"(\d+)",
            Replacement = null
        };

        // Act
        var vm = new RegexTransformerViewModel(model, () => { });

        // Assert
        Assert.False(vm.IsFindReplaceMode);
        Assert.True(vm.IsMatchExtractMode);
    }

    [Fact]
    public void ToModel_SerializesCorrectly_FindReplaceMode()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            ColumnName = "BatchID",
            Pattern = "^IIS_",
            Replacement = "",
            IsFindReplaceMode = true,
            IgnoreCase = true,
            NonMatchBehavior = NonMatchBehavior.KeepOriginal
        };

        // Act
        var model = vm.ToModel();

        // Assert
        Assert.Equal("Regex", model.Type);
        Assert.Equal("BatchID", model.ColumnName);
        Assert.Equal("^IIS_", model.Pattern);
        Assert.Equal("", model.Replacement);
        Assert.True(model.IgnoreCase);
        Assert.Equal(NonMatchBehavior.KeepOriginal, model.NonMatchBehavior);
    }

    [Fact]
    public void ToModel_SerializesCorrectly_MatchExtractMode()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            ColumnName = "Code",
            Pattern = @"(\d+)",
            IsFindReplaceMode = false
        };

        // Act
        var model = vm.ToModel();

        // Assert
        Assert.Null(model.Replacement); // null indicates Match & Extract mode
    }

    [Fact]
    public void TestPatternCommand_ValidPattern_ShowsResult()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            Pattern = "^IIS_",
            Replacement = "",
            IsFindReplaceMode = true,
            TestInput = "IIS_12345"
        };

        // Act
        vm.TestPatternCommand.Execute(null);

        // Assert
        Assert.True(vm.HasTestResult);
        Assert.False(vm.HasTestError);
        Assert.Equal("12345", vm.TestResultValue);
        Assert.Equal("Output", vm.TestResultLabel);
        Assert.Equal("✓", vm.TestResultIcon);
    }

    [Fact]
    public void TestPatternCommand_InvalidPattern_ShowsError()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            Pattern = "[invalid(regex",
            Replacement = "",
            TestInput = "test"
        };

        // Act
        vm.TestPatternCommand.Execute(null);

        // Assert
        Assert.False(vm.HasTestResult);
        Assert.True(vm.HasTestError);
        Assert.NotEmpty(vm.TestErrorMessage);
    }

    [Fact]
    public void TestPatternCommand_MatchExtract_NoMatch_ShowsNonMatchBehavior()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            Pattern = @"(\d+)",
            IsFindReplaceMode = false,
            NonMatchBehavior = NonMatchBehavior.ReturnNull,
            TestInput = "NoNumbers"
        };

        // Act
        vm.TestPatternCommand.Execute(null);

        // Assert
        Assert.True(vm.HasTestResult);
        Assert.Equal("No Match", vm.TestResultLabel);
        Assert.Equal("(null)", vm.TestResultValue);
    }

    [Fact]
    public void ModeSwitch_UpdatesPatternHelpText()
    {
        // Arrange
        var vm = new RegexTransformerViewModel(() => { })
        {
            IsFindReplaceMode = true
        };
        var findReplaceHelp = vm.PatternHelpText;

        // Act
        vm.IsFindReplaceMode = false;
        var matchExtractHelp = vm.PatternHelpText;

        // Assert
        Assert.NotEqual(findReplaceHelp, matchExtractHelp);
        Assert.Contains("capture group", matchExtractHelp, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public void Summary_ShowsColumnAndMode()
    {
        // Arrange & Act
        var vm = new RegexTransformerViewModel(() => { })
        {
            ColumnName = "BatchID",
            IsFindReplaceMode = true
        };

        // Assert
        Assert.Contains("BatchID", vm.Summary);
        Assert.Contains("Replace", vm.Summary);
    }

    [Fact]
    public void PropertyChange_NotifiesChanged()
    {
        // Arrange
        var changedCalled = false;
        var vm = new RegexTransformerViewModel(() => changedCalled = true);

        // Act
        vm.ColumnName = "NewColumn";

        // Assert
        Assert.True(changedCalled);
    }
}