Refactor test code for improved readability by removing unnecessary blank lines

Author: jongalloway

tests/NLWebNet.Tests/Integration/BackendOperationTests.cs

@@ -52,7 +52,7 @@ public async Task BackendOperation_MockDataBackend_AllOperationsWork()
         // Test basic search
         var searchResults = await mockBackend.SearchAsync("millennium falcon", null, 10, CancellationToken.None);
         var resultsList = searchResults.ToList();
-        
+
         Assert.IsTrue(resultsList.Count > 0, "Should return results for 'millennium falcon'");
         Assert.IsTrue(resultsList.Count <= 10, "Should respect max results limit");
 
@@ -73,7 +73,7 @@ public async Task BackendOperation_MockDataBackend_AllOperationsWork()
         {
             foreach (var result in siteFilteredList)
             {
-                Assert.AreEqual("scifi-cinema.com", result.Site, 
+                Assert.AreEqual("scifi-cinema.com", result.Site,
                     "All results should be from the specified site when site filtering is applied");
             }
             Console.WriteLine($"✓ Site filtering returned {siteFilteredList.Count} results from scifi-cinema.com");
@@ -113,7 +113,7 @@ public async Task BackendOperation_BackendManager_ManagesBackendsCorrectly()
             Assert.IsFalse(string.IsNullOrWhiteSpace(backend.Id), "Backend ID should not be empty");
             Assert.IsNotNull(backend.Capabilities, "Backend capabilities should not be null");
             Assert.IsFalse(string.IsNullOrWhiteSpace(backend.Capabilities.Description), "Backend description should not be empty");
-            
+
             Console.WriteLine($"Backend: {backend.Id} - {backend.Capabilities.Description}");
             Console.WriteLine($"  Write endpoint: {backend.IsWriteEndpoint}");
         }
@@ -156,7 +156,7 @@ public async Task BackendOperation_Capabilities_ReflectActualLimitations()
         // Test max results limitation
         var maxResultsQuery = await mockBackend.SearchAsync("space", null, capabilities.MaxResults + 10, CancellationToken.None);
         var maxResultsList = maxResultsQuery.ToList();
-        
+
         Assert.IsTrue(maxResultsList.Count <= capabilities.MaxResults,
             $"Should not return more than MaxResults ({capabilities.MaxResults}). Got {maxResultsList.Count}");
 
@@ -179,7 +179,7 @@ public async Task BackendOperation_Capabilities_ReflectActualLimitations()
         }
 
         // Test semantic search capability (should be false for MockDataBackend)
-        Assert.IsFalse(capabilities.SupportsSemanticSearch, 
+        Assert.IsFalse(capabilities.SupportsSemanticSearch,
             "MockDataBackend should not support semantic search");
         Console.WriteLine("✓ Semantic search capability correctly reported as not supported");
     }
@@ -213,7 +213,7 @@ public async Task BackendOperation_ErrorHandling_HandlesFaultyConditionsGraceful
         // Test with very large max results
         var largeMaxResults = await mockBackend.SearchAsync("test", null, int.MaxValue, CancellationToken.None);
         var largeResultsList = largeMaxResults.ToList();
-        
+
         // Should not crash or cause issues
         Assert.IsTrue(largeResultsList.Count >= 0, "Should handle large max results gracefully");
         Console.WriteLine($"✓ Large max results handled gracefully: {largeResultsList.Count} results");
@@ -222,7 +222,7 @@ public async Task BackendOperation_ErrorHandling_HandlesFaultyConditionsGraceful
         var longQuery = new string('a', 10000); // 10k character query
         var longQueryResults = await mockBackend.SearchAsync(longQuery, null, 10, CancellationToken.None);
         var longQueryList = longQueryResults.ToList();
-        
+
         // Should not crash
         Assert.IsTrue(longQueryList.Count >= 0, "Should handle long queries gracefully");
         Console.WriteLine($"✓ Long query handled gracefully: {longQueryList.Count} results");
@@ -254,11 +254,11 @@ public async Task BackendOperation_Performance_MeetsExpectedCharacteristics()
             stopwatch.Stop();
 
             var elapsedMs = stopwatch.ElapsedMilliseconds;
-            
+
             // Mock backend should be reasonably fast (< 500ms) in test environment
-            Assert.IsTrue(elapsedMs < 500, 
+            Assert.IsTrue(elapsedMs < 500,
                 $"MockDataBackend should be reasonably fast. Query '{query}' took {elapsedMs}ms");
-            
+
             Console.WriteLine($"✓ Query '{query}' completed in {elapsedMs}ms with {resultsList.Count} results");
         }
 

tests/NLWebNet.Tests/Integration/EndToEndQueryTests.cs

@@ -19,7 +19,7 @@ public class EndToEndQueryTests
     public void Initialize()
     {
         var services = new ServiceCollection();
-        
+
         // Configure with default settings
         services.AddNLWebNetMultiBackend(options =>
         {
@@ -50,23 +50,23 @@ public async Task EndToEnd_BasicSearchScenarios_AllPass()
         foreach (var scenario in basicSearchScenarios)
         {
             Console.WriteLine($"Testing scenario: {scenario.Name}");
-            
+
             var request = scenario.ToRequest();
             var response = await _nlWebService.ProcessRequestAsync(request);
 
             // Assert basic response properties
             Assert.IsNotNull(response, $"Response should not be null for scenario: {scenario.Name}");
             Assert.AreEqual(request.QueryId, response.QueryId, "QueryId should match");
             Assert.IsNull(response.Error, $"Response should not have error for scenario: {scenario.Name}");
-            
+
             // Assert result count
             if (scenario.MinExpectedResults > 0)
             {
                 Assert.IsNotNull(response.Results, $"Results should not be null for scenario: {scenario.Name}");
                 Assert.IsTrue(response.Results.Count() >= scenario.MinExpectedResults,
                     $"Should have at least {scenario.MinExpectedResults} results for scenario: {scenario.Name}");
             }
-            
+
             Console.WriteLine($"✓ Scenario '{scenario.Name}' passed with {response.Results?.Count() ?? 0} results");
         }
     }
@@ -83,14 +83,14 @@ public async Task EndToEnd_EdgeCaseScenarios_HandleCorrectly()
         foreach (var scenario in edgeCaseScenarios)
         {
             Console.WriteLine($"Testing edge case: {scenario.Name}");
-            
+
             var request = scenario.ToRequest();
             var response = await _nlWebService.ProcessRequestAsync(request);
 
             // Edge cases should not throw exceptions
             Assert.IsNotNull(response, $"Response should not be null for edge case: {scenario.Name}");
             Assert.AreEqual(request.QueryId, response.QueryId, "QueryId should match");
-            
+
             // Edge cases might have zero results, which is acceptable
             var resultCount = response.Results?.Count() ?? 0;
             Console.WriteLine($"✓ Edge case '{scenario.Name}' handled correctly with {resultCount} results");
@@ -109,27 +109,27 @@ public async Task EndToEnd_SiteFilteringScenarios_FilterCorrectly()
         foreach (var scenario in siteFilteringScenarios)
         {
             Console.WriteLine($"Testing site filtering: {scenario.Name}");
-            
+
             var request = scenario.ToRequest();
             var response = await _nlWebService.ProcessRequestAsync(request);
 
             Assert.IsNotNull(response, $"Response should not be null for scenario: {scenario.Name}");
             Assert.IsNull(response.Error, $"Response should not have error for scenario: {scenario.Name}");
-            
+
             if (response.Results?.Any() == true && !string.IsNullOrEmpty(scenario.Site))
             {
                 // Verify site filtering is applied (all results should be from the specified site)
-                var resultsFromOtherSites = response.Results.Where(r => 
-                    !string.IsNullOrEmpty(r.Site) && 
+                var resultsFromOtherSites = response.Results.Where(r =>
+                    !string.IsNullOrEmpty(r.Site) &&
                     !r.Site.Equals(scenario.Site, StringComparison.OrdinalIgnoreCase)).ToList();
-                
+
                 if (resultsFromOtherSites.Count > 0)
                 {
                     Console.WriteLine($"Warning: Found {resultsFromOtherSites.Count} results from other sites. " +
                         "This might be expected if site filtering is not strictly enforced.");
                 }
             }
-            
+
             Console.WriteLine($"✓ Site filtering scenario '{scenario.Name}' completed");
         }
     }
@@ -146,19 +146,19 @@ public async Task EndToEnd_TechnicalQueries_ReturnRelevantResults()
         foreach (var scenario in technicalScenarios)
         {
             Console.WriteLine($"Testing technical query: {scenario.Name}");
-            
+
             var request = scenario.ToRequest();
             var response = await _nlWebService.ProcessRequestAsync(request);
 
             Assert.IsNotNull(response, $"Response should not be null for scenario: {scenario.Name}");
             Assert.IsNull(response.Error, $"Response should not have error for scenario: {scenario.Name}");
-            
+
             if (scenario.MinExpectedResults > 0)
             {
                 Assert.IsNotNull(response.Results, $"Results should not be null for scenario: {scenario.Name}");
                 Assert.IsTrue(response.Results.Count() >= scenario.MinExpectedResults,
                     $"Should have at least {scenario.MinExpectedResults} results for scenario: {scenario.Name}");
-                
+
                 // Verify results have meaningful content
                 foreach (var result in response.Results.Take(3)) // Check first 3 results
                 {
@@ -167,7 +167,7 @@ public async Task EndToEnd_TechnicalQueries_ReturnRelevantResults()
                     Assert.IsFalse(string.IsNullOrWhiteSpace(result.Url), "Result URL should not be empty");
                 }
             }
-            
+
             Console.WriteLine($"✓ Technical query '{scenario.Name}' passed with {response.Results?.Count() ?? 0} results");
         }
     }
@@ -184,7 +184,7 @@ public async Task EndToEnd_DifferentQueryModes_WorkCorrectly()
         foreach (var mode in queryModes)
         {
             Console.WriteLine($"Testing query mode: {mode}");
-            
+
             var request = new NLWebRequest
             {
                 QueryId = $"test-mode-{mode}-{Guid.NewGuid():N}",
@@ -197,7 +197,7 @@ public async Task EndToEnd_DifferentQueryModes_WorkCorrectly()
             Assert.IsNotNull(response, $"Response should not be null for mode: {mode}");
             Assert.AreEqual(request.QueryId, response.QueryId, "QueryId should match");
             Assert.IsNull(response.Error, $"Response should not have error for mode: {mode}");
-            
+
             Console.WriteLine($"✓ Query mode '{mode}' worked correctly");
         }
     }
@@ -225,10 +225,10 @@ public async Task EndToEnd_StreamingQueries_StreamCorrectly()
             {
                 responseCount++;
                 lastResponse = response;
-                
+
                 Assert.IsNotNull(response, "Streamed response should not be null");
                 Assert.AreEqual(request.QueryId, response.QueryId, "QueryId should match in streamed response");
-                
+
                 // Break after a reasonable number of responses to avoid long test
                 if (responseCount >= 5) break;
             }
@@ -242,7 +242,7 @@ public async Task EndToEnd_StreamingQueries_StreamCorrectly()
 
         Assert.IsTrue(responseCount > 0, "Should receive at least one streamed response");
         Assert.IsNotNull(lastResponse, "Should have received at least one response");
-        
+
         Console.WriteLine($"✓ Streaming test completed with {responseCount} responses");
     }
 }

tests/NLWebNet.Tests/Integration/MultiBackendIntegrationTests.cs

@@ -206,7 +206,7 @@ public async Task EndToEnd_MultiBackendConsistency_ResultsAreConsistent()
         foreach (var scenario in consistencyScenarios)
         {
             Console.WriteLine($"Testing consistency for: {scenario.Name}");
-            
+
             var request = new NLWebRequest
             {
                 QueryId = $"consistency-{Guid.NewGuid():N}",
@@ -233,28 +233,28 @@ public async Task EndToEnd_MultiBackendConsistency_ResultsAreConsistent()
             if (responses.All(r => r.Results?.Any() == true))
             {
                 var firstResults = responses[0].Results!.ToList();
-                
+
                 foreach (var response in responses.Skip(1))
                 {
                     var currentResults = response.Results!.ToList();
-                    
+
                     // Check for reasonable overlap in results
                     var commonUrls = firstResults.Select(r => r.Url)
                         .Intersect(currentResults.Select(r => r.Url))
                         .Count();
-                    
+
                     var overlapPercent = (double)commonUrls / Math.Max(firstResults.Count, currentResults.Count) * 100;
-                    
+
                     Console.WriteLine($"Result overlap: {overlapPercent:F1}% ({commonUrls} common URLs)");
-                    
+
                     // Results should have reasonable consistency for the same query
                     // Note: Some variation is expected due to scoring differences or backend variations
                     Assert.IsTrue(overlapPercent >= scenario.MinOverlapPercent || firstResults.Count <= 2,
                         $"Results should have at least {scenario.MinOverlapPercent}% overlap for consistent queries. " +
                         $"Got {overlapPercent:F1}% for scenario: {scenario.Name}");
                 }
             }
-            
+
             Console.WriteLine($"✓ Consistency validated for '{scenario.Name}'");
         }
     }
@@ -275,32 +275,32 @@ public async Task EndToEnd_BackendCapabilities_AreAccessibleAndValid()
         var backendManager = serviceProvider.GetRequiredService<IBackendManager>();
 
         var backendInfo = backendManager.GetBackendInfo().ToList();
-        
+
         Assert.IsTrue(backendInfo.Count >= 1, "Should have at least one backend configured");
 
         foreach (var backend in backendInfo)
         {
             Console.WriteLine($"Testing backend capabilities: {backend.Id}");
-            
+
             // Verify backend information is complete
             Assert.IsFalse(string.IsNullOrWhiteSpace(backend.Id), "Backend ID should not be empty");
             Assert.IsNotNull(backend.Capabilities, "Backend capabilities should not be null");
             Assert.IsFalse(string.IsNullOrWhiteSpace(backend.Capabilities.Description), "Backend description should not be empty");
-            
+
             // Test backend capabilities
             if (backend.IsWriteEndpoint)
             {
                 var writeBackend = backendManager.GetWriteBackend();
                 Assert.IsNotNull(writeBackend, "Write backend should be accessible");
-                
+
                 var capabilities = writeBackend.GetCapabilities();
                 Assert.IsNotNull(capabilities, "Backend capabilities should not be null");
-                Assert.IsFalse(string.IsNullOrWhiteSpace(capabilities.Description), 
+                Assert.IsFalse(string.IsNullOrWhiteSpace(capabilities.Description),
                     "Backend capabilities description should not be empty");
-                
+
                 Console.WriteLine($"✓ Write backend capabilities verified: {capabilities.Description}");
             }
-            
+
             Console.WriteLine($"✓ Backend '{backend.Id}' capabilities validated");
         }
     }