Fix codacy smells

mistial-dev · mistial-dev · commit 3487b77374d5 · 2025-07-13T23:51:27.000-04:00
diff --git a/src/TestableIO.System.IO.Abstractions.TestingHelpers/Events/MockFileSystemEvents.cs b/src/TestableIO.System.IO.Abstractions.TestingHelpers/Events/MockFileSystemEvents.cs
@@ -74,7 +74,9 @@ public class MockFileSystemEvents
     public IDisposable Subscribe(Action<FileSystemOperationEventArgs> handler)
     {
         if (handler == null)
+        {
             throw new ArgumentNullException(nameof(handler));
+        }
             
         lock (LockObject)
         {
@@ -116,7 +118,9 @@ public IDisposable Subscribe(FileOperation[] operations, Action<FileSystemOperat
         if (handler == null)
             throw new ArgumentNullException(nameof(handler));
         if (operations == null)
+        {
             throw new ArgumentNullException(nameof(operations));
+        }
             
         lock (LockObject)
         {
@@ -144,7 +148,9 @@ public IDisposable Subscribe(FileOperation[] operations, Action<FileSystemOperat
     public T WithEvents<T>(string path, FileOperation operation, ResourceType resourceType, Func<T> func)
     {
         if (!isEnabled)
+        {
             return func();
+        }
             
         RaiseOperation(path, operation, resourceType, OperationPhase.Before);
         
@@ -228,7 +234,9 @@ internal void RaiseOperation(
         lock (LockObject)
         {
             if (subscriptions.Count == 0)
+            {
                 return;
+            }
             currentSubscriptions = subscriptions.ToArray();
         }
         
@@ -249,7 +257,9 @@ internal void RaiseOperation(
         if (exceptions.Count > 0)
         {
             if (exceptions.Count == 1)
+            {
                 throw exceptions[0];
+            }
             throw new AggregateException(
                 $"One or more event handlers failed for {operation} operation on {path}", 
                 exceptions);
@@ -282,17 +292,15 @@ internal void RaiseOperation(
     /// Removes the specified subscription from the list of active subscriptions.
     /// </summary>
     /// <param name="subscription">The subscription to be removed.</param>
-    /// <returns>True if the subscription was successfully removed; otherwise, false.</returns>
-    private bool RemoveSubscription(Subscription subscription)
+    private void RemoveSubscription(Subscription subscription)
     {
         lock (LockObject)
         {
             if (!subscriptions.Remove(subscription))
             {
-                return false;
+                return;
             }
             Interlocked.Increment(ref subscriptionVersion);
-            return true;
         }
     }
     
diff --git a/src/TestableIO.System.IO.Abstractions.TestingHelpers/MockFileSystemOptions.cs b/src/TestableIO.System.IO.Abstractions.TestingHelpers/MockFileSystemOptions.cs
@@ -19,5 +19,5 @@ public class MockFileSystemOptions
     /// Flag indicating whether file system events should be enabled.
     /// When false (default), the event system has zero overhead.
     /// </summary>
-    public bool EnableEvents { get; init; } = false;
+    public bool EnableEvents { get; init; }
 }
diff --git a/tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockFileSystemCreativeEventsTests.cs b/tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockFileSystemCreativeEventsTests.cs
@@ -56,7 +56,10 @@ public void Events_FileSystemOperationTracker_ShouldCreateOperationLog()
 
         using (fileSystem.Events.Subscribe(args =>
                {
-                   if (args.Phase != OperationPhase.After) return;
+                   if (args.Phase != OperationPhase.After)
+                   {
+                       return;
+                   }
                    var logEntry = args.Operation switch
                    {
                        FileOperation.Create => $"Created new file at {args.Path}",
@@ -161,13 +164,19 @@ public void Events_FileSystemProgressTracker_ShouldTrackExperiencePoints()
                 // Milestone tracking
                 var opsPerformed = (int)playerStats["operations_performed"];
                 if (opsPerformed == 10 && !milestones.Contains("Completed 10 operations"))
+                {
                     milestones.Add("Completed 10 operations");
+                }
 
                 if (args.Operation == FileOperation.Delete && !milestones.Contains("First file deletion"))
+                {
                     milestones.Add("First file deletion");
+                }
 
                 if (args.Path.EndsWith(".exe") && !milestones.Contains("Handled executable file"))
+                {
                     milestones.Add("Handled executable file");
+                }
             }
         }))
         {
@@ -329,9 +338,15 @@ public void Events_QuantumFileSystem_ShouldImplementSuperpositionPattern()
 
         using (fileSystem.Events.Subscribe(args =>
                {
-                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Read) return;
+                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Read)
+                   {
+                       return;
+                   }
                    // Quantum files exist in superposition until observed (read)
-                   if (!args.Path.Contains("quantum") || quantumStates.ContainsKey(args.Path)) return;
+                   if (!args.Path.Contains("quantum") || quantumStates.ContainsKey(args.Path))
+                   {
+                       return;
+                   }
                    // Collapse the wave function deterministically
                    var exists = deterministicRandom.NextDouble() > 0.5;
                    quantumStates[args.Path] = exists;
@@ -420,7 +435,10 @@ public void Events_AutoCorrectFileSystem_ShouldDetectAndSuggestTypoCorrections()
 
         using (fileSystem.Events.Subscribe(args =>
                {
-                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Create) return;
+                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Create)
+                   {
+                       return;
+                   }
                    var fileName = fileSystem.Path.GetFileNameWithoutExtension(args.Path);
 
                    // Check for potential typos
@@ -484,7 +502,10 @@ public void Events_ReliabilityTestingSystem_ShouldSimulateControlledFailures()
 
         using (fileSystem.Events.Subscribe(args =>
                {
-                   if (args.Phase != OperationPhase.Before) return;
+                   if (args.Phase != OperationPhase.Before)
+                   {
+                       return;
+                   }
                    operationCount++;
 
                    // Simulate controlled failure scenarios
@@ -587,7 +608,10 @@ public void Events_AccessPatternMonitor_ShouldTrackSuspiciousActivity()
 
         using (fileSystem.Events.Subscribe(args =>
                {
-                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Read) return;
+                   if (args.Phase != OperationPhase.Before || args.Operation != FileOperation.Read)
+                   {
+                       return;
+                   }
                    accessCounts[args.Path] = (accessCounts.TryGetValue(args.Path, out var count) ? count : 0) + 1;
                    var accesses = accessCounts[args.Path];
 
@@ -613,6 +637,9 @@ public void Events_AccessPatternMonitor_ShouldTrackSuspiciousActivity()
                                Exception = new UnauthorizedAccessException("Access denied: Suspicious activity pattern detected")
                            });
                            break;
+                       default:
+                           // No action for access counts > 4
+                           break;
                    }
                }))
         {
@@ -690,11 +717,16 @@ public void Events_PerformanceProfiler_ShouldTrackOperationMetrics()
             else if (args.Phase == OperationPhase.After)
             {
                 var beforeKey = key.Replace("_After", "_Before");
-                if (!operationTimestamps.TryGetValue(beforeKey, out var timestamp)) return;
+                if (!operationTimestamps.TryGetValue(beforeKey, out var timestamp))
+                {
+                    return;
+                }
                 var duration = (DateTime.UtcNow - timestamp).Ticks;
 
                 if (!performanceMetrics.ContainsKey(args.Operation))
+                {
                     performanceMetrics[args.Operation] = new List<long>();
+                }
 
                 performanceMetrics[args.Operation].Add(duration);
                 operationTimestamps.Remove(beforeKey);
@@ -759,7 +791,9 @@ public void Events_PerformanceProfiler_ShouldTrackOperationMetrics()
     private static bool IsLikelyTypo(string input, string target)
     {
         if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(target))
+        {
             return false;
+        }
             
         // Simple Levenshtein distance check for typo detection
         var distance = CalculateLevenshteinDistance(input.ToLowerInvariant(), target.ToLowerInvariant());
@@ -775,15 +809,25 @@ private static bool IsLikelyTypo(string input, string target)
     /// <returns>The Levenshtein distance as an integer, representing the number of edits required to transform the source string into the target string.</returns>
     private static int CalculateLevenshteinDistance(string source, string target)
     {
-        if (source.Length == 0) return target.Length;
-        if (target.Length == 0) return source.Length;
+        if (source.Length == 0)
+        {
+            return target.Length;
+        }
+        if (target.Length == 0)
+        {
+            return source.Length;
+        }
         
         var matrix = new int[source.Length + 1, target.Length + 1];
         
         for (var i = 0; i <= source.Length; i++)
+        {
             matrix[i, 0] = i;
+        }
         for (var j = 0; j <= target.Length; j++)
+        {
             matrix[0, j] = j;
+        }
             
         for (var i = 1; i <= source.Length; i++)
         {
diff --git a/tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockFileSystemEventsTests.cs b/tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockFileSystemEventsTests.cs
@@ -480,11 +480,11 @@ public void Events_ExceptionInHandler_DoesNotAffectOtherHandlers()
         var fileSystem = new MockFileSystem(new MockFileSystemOptions { EnableEvents = true });
         var handler2Called = false;
         
-        using (fileSystem.Events.Subscribe(args => throw new Exception("Handler 1 error")))
+        using (fileSystem.Events.Subscribe(args => throw new InvalidOperationException("Handler 1 error")))
         using (fileSystem.Events.Subscribe(args => handler2Called = true))
         {
             // The operation should throw the handler exception
-            Assert.Throws<Exception>(() => fileSystem.File.Create(XFS.Path(@"C:\test.txt")));
+            Assert.Throws<InvalidOperationException>(() => fileSystem.File.Create(XFS.Path(@"C:\test.txt")));
             
             // But handler2 should have been called
             Assert.That(handler2Called, Is.True);

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,9 @@ public class MockFileSystemEvents`
`74`	`74`	`public IDisposable Subscribe(Action<FileSystemOperationEventArgs> handler)`
`75`	`75`	`{`
`76`	`76`	`if (handler == null)`
	`77`	`+ {`
`77`	`78`	`throw new ArgumentNullException(nameof(handler));`
	`79`	`+ }`
`78`	`80`
`79`	`81`	`lock (LockObject)`
`80`	`82`	`{`
`@@ -116,7 +118,9 @@ public IDisposable Subscribe(FileOperation[] operations, Action<FileSystemOperat`
`116`	`118`	`if (handler == null)`
`117`	`119`	`throw new ArgumentNullException(nameof(handler));`
`118`	`120`	`if (operations == null)`
	`121`	`+ {`
`119`	`122`	`throw new ArgumentNullException(nameof(operations));`
	`123`	`+ }`
`120`	`124`
`121`	`125`	`lock (LockObject)`
`122`	`126`	`{`
`@@ -144,7 +148,9 @@ public IDisposable Subscribe(FileOperation[] operations, Action<FileSystemOperat`
`144`	`148`	`public T WithEvents<T>(string path, FileOperation operation, ResourceType resourceType, Func<T> func)`
`145`	`149`	`{`
`146`	`150`	`if (!isEnabled)`
	`151`	`+ {`
`147`	`152`	`return func();`
	`153`	`+ }`
`148`	`154`
`149`	`155`	`RaiseOperation(path, operation, resourceType, OperationPhase.Before);`
`150`	`156`
`@@ -228,7 +234,9 @@ internal void RaiseOperation(`
`228`	`234`	`lock (LockObject)`
`229`	`235`	`{`
`230`	`236`	`if (subscriptions.Count == 0)`
	`237`	`+ {`
`231`	`238`	`return;`
	`239`	`+ }`
`232`	`240`	`currentSubscriptions = subscriptions.ToArray();`
`233`	`241`	`}`
`234`	`242`
`@@ -249,7 +257,9 @@ internal void RaiseOperation(`
`249`	`257`	`if (exceptions.Count > 0)`
`250`	`258`	`{`
`251`	`259`	`if (exceptions.Count == 1)`
	`260`	`+ {`
`252`	`261`	`throw exceptions[0];`
	`262`	`+ }`
`253`	`263`	`throw new AggregateException(`
`254`	`264`	`$"One or more event handlers failed for {operation} operation on {path}",`
`255`	`265`	`exceptions);`
`@@ -282,17 +292,15 @@ internal void RaiseOperation(`
`282`	`292`	`/// Removes the specified subscription from the list of active subscriptions.`
`283`	`293`	`/// </summary>`
`284`	`294`	`/// <param name="subscription">The subscription to be removed.</param>`
`285`		`- /// <returns>True if the subscription was successfully removed; otherwise, false.</returns>`
`286`		`- private bool RemoveSubscription(Subscription subscription)`
	`295`	`+ private void RemoveSubscription(Subscription subscription)`
`287`	`296`	`{`
`288`	`297`	`lock (LockObject)`
`289`	`298`	`{`
`290`	`299`	`if (!subscriptions.Remove(subscription))`
`291`	`300`	`{`
`292`		`- return false;`
	`301`	`+ return;`
`293`	`302`	`}`
`294`	`303`	`Interlocked.Increment(ref subscriptionVersion);`
`295`		`- return true;`
`296`	`304`	`}`
`297`	`305`	`}`
`298`	`306`
Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,5 @@ public class MockFileSystemOptions`
`19`	`19`	`/// Flag indicating whether file system events should be enabled.`
`20`	`20`	`/// When false (default), the event system has zero overhead.`
`21`	`21`	`/// </summary>`
`22`		`- public bool EnableEvents { get; init; } = false;`
	`22`	`+ public bool EnableEvents { get; init; }`
`23`	`23`	`}`