unit tests fix

Author: BRUNER Patrick

src/PluginRegistry.Tests/PluginHashCalculatorTests.cs

@@ -9,19 +9,26 @@ public class PluginHashCalculatorTests
 {
     private string _testDirectory;
     private string _testFilePath;
+    private bool _originalBypassSetting;
 
     [SetUp]
     public void SetUp ()
     {
         _testDirectory = Path.Join(Path.GetTempPath(), "LogExpertPluginHashTests");
         _ = Directory.CreateDirectory(_testDirectory);
         _testFilePath = Path.Join(_testDirectory, "test-plugin.dll");
+
+        // Save original bypass setting and disable it for tests that need actual verification
+        _originalBypassSetting = PluginHashCalculator.BypassHashVerification;
     }
 
     [TearDown]
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Unit testcases")]
     public void TearDown ()
     {
+        // Restore original bypass setting
+        PluginHashCalculator.BypassHashVerification = _originalBypassSetting;
+
         try
         {
             if (Directory.Exists(_testDirectory))
@@ -121,6 +128,7 @@ public void CalculateHash_WhitespacePath_ThrowsArgumentException ()
     public void VerifyHash_MatchingHash_ReturnsTrue ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var testContent = "Test content for hash verification";
         File.WriteAllText(_testFilePath, testContent);
         var expectedHash = PluginHashCalculator.CalculateHash(_testFilePath);
@@ -136,6 +144,7 @@ public void VerifyHash_MatchingHash_ReturnsTrue ()
     public void VerifyHash_MismatchedHash_ReturnsFalse ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var testContent = "Test content";
         File.WriteAllText(_testFilePath, testContent);
         var wrongHash = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
@@ -151,6 +160,7 @@ public void VerifyHash_MismatchedHash_ReturnsFalse ()
     public void VerifyHash_CaseInsensitiveUpperCase_ReturnsTrue ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var testContent = "Test content";
         File.WriteAllText(_testFilePath, testContent);
         var hash = PluginHashCalculator.CalculateHash(_testFilePath);
@@ -168,6 +178,7 @@ public void VerifyHash_CaseInsensitiveUpperCase_ReturnsTrue ()
     public void VerifyHash_CaseInsensitiveLowerCase_ReturnsTrue ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var testContent = "Test content";
         File.WriteAllText(_testFilePath, testContent);
         var hash = PluginHashCalculator.CalculateHash(_testFilePath);
@@ -184,6 +195,7 @@ public void VerifyHash_CaseInsensitiveLowerCase_ReturnsTrue ()
     public void VerifyHash_ModifiedFile_ReturnsFalse ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var originalContent = "Original content";
         File.WriteAllText(_testFilePath, originalContent);
         var originalHash = PluginHashCalculator.CalculateHash(_testFilePath);
@@ -203,6 +215,7 @@ public void VerifyHash_ModifiedFile_ReturnsFalse ()
     public void VerifyHash_NullExpectedHash_ThrowsArgumentNullException ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         File.WriteAllText(_testFilePath, "Test content");
 
         // Act & Assert
@@ -213,12 +226,29 @@ public void VerifyHash_NullExpectedHash_ThrowsArgumentNullException ()
     public void VerifyHash_EmptyExpectedHash_ThrowsArgumentException ()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         File.WriteAllText(_testFilePath, "Test content");
 
         // Act & Assert
         _ = Assert.Throws<ArgumentException>(() => PluginHashCalculator.VerifyHash(_testFilePath, string.Empty));
     }
 
+    [Test]
+    public void VerifyHash_WithBypassEnabled_AlwaysReturnsTrue ()
+    {
+        // Arrange
+        PluginHashCalculator.BypassHashVerification = true;
+        var testContent = "Test content";
+        File.WriteAllText(_testFilePath, testContent);
+        var wrongHash = "WRONGHASH123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456";
+
+        // Act
+        var result = PluginHashCalculator.VerifyHash(_testFilePath, wrongHash);
+
+        // Assert
+        Assert.That(result, Is.True, "Bypass mode should always return true");
+    }
+
     [Test]
     public void CalculateHashes_MultipleFiles_ReturnsAllHashes ()
     {

src/PluginRegistry.Tests/PluginValidatorTests.cs

@@ -15,6 +15,7 @@ public class PluginValidatorTests
 {
     private string _testDataPath = null!;
     private string _testPluginsPath = null!;
+    private bool _originalBypassSetting;
 
     [SetUp]
     public void SetUp()
@@ -23,11 +24,17 @@ public void SetUp()
         _testDataPath = Path.Join(Path.GetTempPath(), "LogExpertValidatorTests", Guid.NewGuid().ToString());
         _testPluginsPath = Path.Join(_testDataPath, "plugins");
         Directory.CreateDirectory(_testPluginsPath);
+
+        // Save original bypass setting
+        _originalBypassSetting = PluginHashCalculator.BypassHashVerification;
     }
 
     [TearDown]
     public void TearDown()
     {
+        // Restore original bypass setting
+        PluginHashCalculator.BypassHashVerification = _originalBypassSetting;
+
         // Clean up test directories
         if (Directory.Exists(_testDataPath))
         {
@@ -161,6 +168,7 @@ public void CalculateHash_WithEmptyFile_ShouldReturnValidHash()
     public void VerifyHash_WithMatchingHash_ShouldReturnTrue()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var pluginPath = Path.Join(_testPluginsPath, "TestPlugin.dll");
         CreateDummyDll(pluginPath, content: "Test Content");
         var expectedHash = PluginHashCalculator.CalculateHash(pluginPath);
@@ -176,6 +184,7 @@ public void VerifyHash_WithMatchingHash_ShouldReturnTrue()
     public void VerifyHash_WithMismatchedHash_ShouldReturnFalse()
     {
         // Arrange
+        PluginHashCalculator.BypassHashVerification = false;
         var pluginPath = Path.Join(_testPluginsPath, "TestPlugin.dll");
         CreateDummyDll(pluginPath, content: "Test Content");
         var wrongHash = "0000000000000000000000000000000000000000000000000000000000000000";

src/PluginRegistry/PluginHashCalculator.cs

@@ -8,6 +8,17 @@ namespace LogExpert.PluginRegistry;
 /// </summary>
 public static class PluginHashCalculator
 {
+    /// <summary>
+    /// When true, hash verification is bypassed (useful for development and testing).
+    /// Default is true in DEBUG builds, false in RELEASE builds.
+    /// </summary>
+    public static bool BypassHashVerification { get; set; } =
+#if DEBUG
+        true;
+#else
+        false;
+#endif
+
     /// <summary>
     /// Calculates the SHA256 hash of a plugin DLL file.
     /// </summary>
@@ -47,20 +58,25 @@ public static string CalculateHash (string filePath)
     /// <returns>True if the file's hash matches the expected hash, false otherwise.</returns>
     /// <exception cref="ArgumentNullException">Thrown when filePath or expectedHash is null or empty.</exception>
     /// <exception cref="FileNotFoundException">Thrown when the file does not exist.</exception>
+    /// <remarks>
+    /// When <see cref="BypassHashVerification"/> is true, this method always returns true
+    /// to facilitate development and testing scenarios.
+    /// </remarks>
     public static bool VerifyHash (string filePath, string expectedHash)
     {
-        // In Debug mode we trust the plugins (so testing and developing is possible)
-#if DEBUG
-        return true;
-#else
+        // Allow bypassing hash verification for development and testing
+        if (BypassHashVerification)
+        {
+            return true;
+        }
+
         ArgumentException.ThrowIfNullOrWhiteSpace(filePath);
         ArgumentException.ThrowIfNullOrWhiteSpace(expectedHash);
 
         var actualHash = CalculateHash(filePath);
 
         // Case-insensitive comparison
         return string.Equals(actualHash, expectedHash, StringComparison.OrdinalIgnoreCase);
-#endif
     }
 
     /// <summary>

src/RegexColumnizer.UnitTests/RegexColumnizerErrorHandlingTests.cs

@@ -22,6 +22,7 @@ public void SetUp ()
     }
 
     [TearDown]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Unit Tests")]
     public void TearDown ()
     {
         if (Directory.Exists(_testDirectory))
@@ -54,7 +55,7 @@ public void Init_InvalidRegex_SetsRegexToNullAndUsesEmptyColumns ()
         configField?.SetValue(columnizer, config);
 
         // Act - Should not throw
-        Assert.DoesNotThrow(() => columnizer.Init());
+        Assert.DoesNotThrow(columnizer.Init);
 
         // Assert - Regex should be null
         var regexProperty = typeof(BaseRegexColumnizer).GetProperty("Regex");
@@ -80,7 +81,7 @@ public void Init_CatastrophicBacktracking_HandledByRegexHelper ()
 
         // Act - Should complete quickly due to RegexHelper timeout protection
         var stopwatch = System.Diagnostics.Stopwatch.StartNew();
-        Assert.DoesNotThrow(() => columnizer.Init());
+        Assert.DoesNotThrow(columnizer.Init);
         stopwatch.Stop();
 
         // Assert - Should complete in reasonable time (RegexHelper has timeout)
@@ -281,7 +282,7 @@ public void Init_EmptyExpression_HandlesGracefully ()
         configField?.SetValue(columnizer, config);
 
         // Act - Should not throw
-        Assert.DoesNotThrow(() => columnizer.Init());
+        Assert.DoesNotThrow(columnizer.Init);
 
         // Assert - Regex might be null or default
         var regexProperty = typeof(BaseRegexColumnizer).GetProperty("Regex");