fix: IsFailingError respects default rule severity instead of always returning true (#66)

* Initial plan

* fix: IsFailingError now respects default rule severity for codes without overrides

Agent-Logs-Url: https://github.com/304NotModified/SLNX-validator/sessions/e9e9ca8e-b72a-4da4-8d65-36374c08b9ff

Co-authored-by: 304NotModified <5808377+304NotModified@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: 304NotModified <5808377+304NotModified@users.noreply.github.com>

Author: Copilot

src/SLNX-validator.Core/Reporting/SeverityOverrides.cs

@@ -26,9 +26,8 @@ public bool IsVisible(ValidationErrorCode code) =>
 
     public bool IsFailingError(ValidationErrorCode code)
     {
-        if (_overrides.TryGetValue(code, out var severity))
-            return severity is RuleSeverity.BLOCKER or RuleSeverity.CRITICAL or RuleSeverity.MAJOR;
-        return true; // default: all errors are failing
+        var effectiveSeverity = GetEffectiveSeverity(code);
+        return effectiveSeverity is RuleSeverity.BLOCKER or RuleSeverity.CRITICAL or RuleSeverity.MAJOR;
     }
 
     public RuleSeverity GetEffectiveSeverity(ValidationErrorCode code)

tests/SLNX-validator.Core.Tests/SeverityOverridesTests.cs

@@ -0,0 +1,135 @@
+using AwesomeAssertions;
+using JulianVerdurmen.SlnxValidator.Core.Reporting;
+using JulianVerdurmen.SlnxValidator.Core.ValidationResults;
+
+namespace JulianVerdurmen.SlnxValidator.Core.Tests;
+
+public class SeverityOverridesTests
+{
+    #region IsFailingError – no overrides
+
+    [Test]
+    public void IsFailingError_NoOverride_MajorDefaultCode_ReturnsTrue()
+    {
+        // Arrange
+        var overrides = SeverityOverrides.Empty;
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.FileNotFound);
+
+        // Assert
+        result.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsFailingError_NoOverride_MinorDefaultCode_ReturnsFalse()
+    {
+        // Arrange
+        var overrides = SeverityOverrides.Empty;
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.InvalidExtension);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsFailingError_NoOverride_MinorDefaultCode_InvalidWildcardUsage_ReturnsFalse()
+    {
+        // Arrange
+        var overrides = SeverityOverrides.Empty;
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.InvalidWildcardUsage);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    #endregion
+
+    #region IsFailingError – with overrides
+
+    [Test]
+    public void IsFailingError_OverriddenToMinor_ReturnsFalse()
+    {
+        // Arrange
+        var overrides = new SeverityOverrides(new Dictionary<ValidationErrorCode, RuleSeverity?>
+        {
+            { ValidationErrorCode.FileNotFound, RuleSeverity.MINOR }
+        });
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.FileNotFound);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsFailingError_OverriddenToInfo_ReturnsFalse()
+    {
+        // Arrange
+        var overrides = new SeverityOverrides(new Dictionary<ValidationErrorCode, RuleSeverity?>
+        {
+            { ValidationErrorCode.FileNotFound, RuleSeverity.INFO }
+        });
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.FileNotFound);
+
+        // Assert
+        result.Should().BeFalse();
+    }
+
+    [Test]
+    public void IsFailingError_OverriddenToMajor_ReturnsTrue()
+    {
+        // Arrange
+        var overrides = new SeverityOverrides(new Dictionary<ValidationErrorCode, RuleSeverity?>
+        {
+            { ValidationErrorCode.InvalidExtension, RuleSeverity.MAJOR }
+        });
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.InvalidExtension);
+
+        // Assert
+        result.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsFailingError_OverriddenToBlocker_ReturnsTrue()
+    {
+        // Arrange
+        var overrides = new SeverityOverrides(new Dictionary<ValidationErrorCode, RuleSeverity?>
+        {
+            { ValidationErrorCode.FileNotFound, RuleSeverity.BLOCKER }
+        });
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.FileNotFound);
+
+        // Assert
+        result.Should().BeTrue();
+    }
+
+    [Test]
+    public void IsFailingError_OverriddenToCritical_ReturnsTrue()
+    {
+        // Arrange
+        var overrides = new SeverityOverrides(new Dictionary<ValidationErrorCode, RuleSeverity?>
+        {
+            { ValidationErrorCode.FileNotFound, RuleSeverity.CRITICAL }
+        });
+
+        // Act
+        var result = overrides.IsFailingError(ValidationErrorCode.FileNotFound);
+
+        // Assert
+        result.Should().BeTrue();
+    }
+
+    #endregion
+}

tests/SLNX-validator.Tests/ProgramIntegrationTests.cs

@@ -105,16 +105,17 @@ await File.WriteAllTextAsync(slnxPath, """
     }
 
     [Test]
-    public async Task Invoke_WithNonSlnxExtension_ReturnsNonZeroExitCode()
+    public async Task Invoke_WithNonSlnxExtension_ReturnsZeroExitCode()
     {
+        // InvalidExtension (SLNX002) has default severity MINOR, which does not cause exit code 1
         var path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".xml");
         await File.WriteAllTextAsync(path, "<Solution />");
 
         try
         {
             var exitCode = await Program.Main([path]);
 
-            exitCode.Should().NotBe(0);
+            exitCode.Should().Be(0);
         }
         finally
         {