ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests/LockEnforcerTests.cs

using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;

namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests;

public class LockEnforcerTests
{
    // ========================================================================
    // Override Granularity
    // ========================================================================

    /// <summary>Verifies that overriding a locked attribute returns an error.</summary>
    [Fact]
    public void ValidateAttributeOverride_LockedAttribute_ReturnsError()
    {
        var original = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = true, Value = "0"
        };
        var proposed = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = true, Value = "100"
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("locked", result);
    }

    /// <summary>Verifies that changing the data type in an attribute override returns an error.</summary>
    [Fact]
    public void ValidateAttributeOverride_DataTypeChanged_ReturnsError()
    {
        var original = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = false
        };
        var proposed = new TemplateAttribute("Speed")
        {
            DataType = DataType.String, IsLocked = false // DataType changed!
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("DataType", result);
    }

    /// <summary>Verifies that changing the data source reference in an attribute override returns an error.</summary>
    [Fact]
    public void ValidateAttributeOverride_DataSourceReferenceChanged_ReturnsError()
    {
        var original = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = false, DataSourceReference = "tag1"
        };
        var proposed = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = false, DataSourceReference = "tag2" // Changed!
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("DataSourceReference", result);
    }

    /// <summary>Verifies that changing only the value and description in an attribute override returns null.</summary>
    [Fact]
    public void ValidateAttributeOverride_ValueAndDescriptionChanged_ReturnsNull()
    {
        var original = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = false, Value = "0", Description = "old"
        };
        var proposed = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, IsLocked = false, Value = "100", Description = "new"
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.Null(result);
    }

    /// <summary>Verifies that changing the element data type in an attribute override returns an error.</summary>
    [Fact]
    public void ValidateAttributeOverride_ElementDataTypeChanged_ReturnsError()
    {
        // ElementDataType is the element scalar type of a List
        // attribute and is fixed by the defining level, exactly like DataType.
        // TemplateService.UpdateAttributeAsync never copies it onto the persisted
        // row, so a mismatch must be rejected before the Value (validated against
        // the real element type) is persisted against the wrong type.
        var original = new TemplateAttribute("Tags")
        {
            DataType = DataType.List, ElementDataType = DataType.Int32, IsLocked = false
        };
        var proposed = new TemplateAttribute("Tags")
        {
            DataType = DataType.List, ElementDataType = DataType.String, IsLocked = false // changed!
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("ElementDataType", result);
    }

    /// <summary>Verifies that a matching element data type returns null.</summary>
    [Fact]
    public void ValidateAttributeOverride_ElementDataTypeMatches_ReturnsNull()
    {
        var original = new TemplateAttribute("Tags")
        {
            DataType = DataType.List, ElementDataType = DataType.Int32, IsLocked = false, Value = "[1]"
        };
        var proposed = new TemplateAttribute("Tags")
        {
            DataType = DataType.List, ElementDataType = DataType.Int32, IsLocked = false, Value = "[1,2]"
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.Null(result);
    }

    /// <summary>Verifies that both element data types being null returns null.</summary>
    [Fact]
    public void ValidateAttributeOverride_ElementDataTypeBothNull_ReturnsNull()
    {
        // Scalar attributes carry no element type on either side — not a change.
        var original = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, ElementDataType = null, IsLocked = false, Value = "0"
        };
        var proposed = new TemplateAttribute("Speed")
        {
            DataType = DataType.Float, ElementDataType = null, IsLocked = false, Value = "100"
        };

        var result = LockEnforcer.ValidateAttributeOverride(original, proposed);

        Assert.Null(result);
    }

    /// <summary>Verifies that overriding a locked alarm returns an error.</summary>
    [Fact]
    public void ValidateAlarmOverride_LockedAlarm_ReturnsError()
    {
        var original = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.ValueMatch, IsLocked = true, PriorityLevel = 500
        };
        var proposed = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.ValueMatch, IsLocked = true, PriorityLevel = 600
        };

        var result = LockEnforcer.ValidateAlarmOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("locked", result);
    }

    /// <summary>Verifies that changing the trigger type in an alarm override returns an error.</summary>
    [Fact]
    public void ValidateAlarmOverride_TriggerTypeChanged_ReturnsError()
    {
        var original = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.ValueMatch, IsLocked = false
        };
        var proposed = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.RangeViolation, IsLocked = false // Changed!
        };

        var result = LockEnforcer.ValidateAlarmOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("TriggerType", result);
    }

    /// <summary>Verifies that changing the overridable fields of an alarm returns null.</summary>
    [Fact]
    public void ValidateAlarmOverride_OverridableFieldsChanged_ReturnsNull()
    {
        var original = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.ValueMatch, IsLocked = false,
            PriorityLevel = 500, Description = "old"
        };
        var proposed = new TemplateAlarm("HighTemp")
        {
            TriggerType = AlarmTriggerType.ValueMatch, IsLocked = false,
            PriorityLevel = 700, Description = "new", TriggerConfiguration = """{"value": 100}"""
        };

        var result = LockEnforcer.ValidateAlarmOverride(original, proposed);

        Assert.Null(result);
    }

    /// <summary>Verifies that overriding a locked script returns an error.</summary>
    [Fact]
    public void ValidateScriptOverride_LockedScript_ReturnsError()
    {
        var original = new TemplateScript("OnStart", "code") { IsLocked = true };
        var proposed = new TemplateScript("OnStart", "new code") { IsLocked = true };

        var result = LockEnforcer.ValidateScriptOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("locked", result);
    }

    /// <summary>Verifies that changing the name in a script override returns an error.</summary>
    [Fact]
    public void ValidateScriptOverride_NameChanged_ReturnsError()
    {
        var original = new TemplateScript("OnStart", "code") { IsLocked = false };
        var proposed = new TemplateScript("OnStop", "code") { IsLocked = false }; // Name changed!

        var result = LockEnforcer.ValidateScriptOverride(original, proposed);

        Assert.NotNull(result);
        Assert.Contains("Name", result);
    }

    /// <summary>Verifies that changing the overridable fields of a script returns null.</summary>
    [Fact]
    public void ValidateScriptOverride_OverridableFieldsChanged_ReturnsNull()
    {
        var original = new TemplateScript("OnStart", "old code") { IsLocked = false };
        var proposed = new TemplateScript("OnStart", "new code")
        {
            IsLocked = false,
            TriggerType = "Timer",
            MinTimeBetweenRuns = TimeSpan.FromSeconds(30)
        };

        var result = LockEnforcer.ValidateScriptOverride(original, proposed);

        Assert.Null(result);
    }

    // ========================================================================
    // Locking Rules
    // ========================================================================

    /// <summary>Verifies that unlocking a locked member returns an error.</summary>
    [Fact]
    public void ValidateLockChange_UnlockLocked_ReturnsError()
    {
        var result = LockEnforcer.ValidateLockChange(true, false, "Speed");

        Assert.NotNull(result);
        Assert.Contains("cannot be unlocked", result);
    }

    /// <summary>Verifies that locking an unlocked member returns null.</summary>
    [Fact]
    public void ValidateLockChange_LockUnlocked_ReturnsNull()
    {
        var result = LockEnforcer.ValidateLockChange(false, true, "Speed");

        Assert.Null(result);
    }

    /// <summary>Verifies that keeping a member locked returns null.</summary>
    [Fact]
    public void ValidateLockChange_KeepLocked_ReturnsNull()
    {
        var result = LockEnforcer.ValidateLockChange(true, true, "Speed");

        Assert.Null(result);
    }

    /// <summary>Verifies that keeping a member unlocked returns null.</summary>
    [Fact]
    public void ValidateLockChange_KeepUnlocked_ReturnsNull()
    {
        var result = LockEnforcer.ValidateLockChange(false, false, "Speed");

        Assert.Null(result);
    }

    // ========================================================================
    // LockedInDerived one-way ratchet
    // ========================================================================

    /// <summary>Verifies that clearing LockedInDerived returns an error.</summary>
    [Fact]
    public void ValidateLockedInDerivedChange_ClearLocked_ReturnsError()
    {
        // Once a base template marks a member LockedInDerived, the flag may
        // not be cleared — derived overrides previously blocked would
        // otherwise become retroactively legal.
        var result = LockEnforcer.ValidateLockedInDerivedChange(true, false, "Speed");

        Assert.NotNull(result);
        Assert.Contains("locked-in-derived", result);
        Assert.Contains("cannot be cleared", result);
    }

    /// <summary>Verifies that setting LockedInDerived on an unlocked member returns null.</summary>
    [Fact]
    public void ValidateLockedInDerivedChange_LockUnlocked_ReturnsNull()
    {
        // Setting the flag from false→true is the normal direction.
        var result = LockEnforcer.ValidateLockedInDerivedChange(false, true, "Speed");

        Assert.Null(result);
    }

    /// <summary>Verifies that keeping LockedInDerived set returns null.</summary>
    [Fact]
    public void ValidateLockedInDerivedChange_KeepLocked_ReturnsNull()
    {
        var result = LockEnforcer.ValidateLockedInDerivedChange(true, true, "Speed");

        Assert.Null(result);
    }

    /// <summary>Verifies that keeping LockedInDerived unset returns null.</summary>
    [Fact]
    public void ValidateLockedInDerivedChange_KeepUnlocked_ReturnsNull()
    {
        var result = LockEnforcer.ValidateLockedInDerivedChange(false, false, "Speed");

        Assert.Null(result);
    }
}