Refactor tool selection tests to use constants for improved maintainability and consistency

jongalloway · jongalloway · commit 21eb40f72a50 · 2025-07-02T17:27:10.000-07:00
diff --git a/src/NLWebNet/Services/ToolSelector.cs b/src/NLWebNet/Services/ToolSelector.cs
@@ -15,7 +15,7 @@ public class ToolSelector : IToolSelector
     /// <summary>
     /// Constants for tool names and associated keywords
     /// </summary>
-    private static class ToolConstants
+    public static class ToolConstants
     {
         // Tool names
         public const string SearchTool = "search";
diff --git a/tests/NLWebNet.Tests/Integration/EndToEndQueryTests.cs b/tests/NLWebNet.Tests/Integration/EndToEndQueryTests.cs
@@ -45,7 +45,7 @@ public void Cleanup()
     public async Task EndToEnd_BasicSearchScenarios_AllPass()
     {
         var basicSearchScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("BasicSearch"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.BasicSearch));
 
         foreach (var scenario in basicSearchScenarios)
         {
@@ -78,7 +78,7 @@ public async Task EndToEnd_BasicSearchScenarios_AllPass()
     public async Task EndToEnd_EdgeCaseScenarios_HandleCorrectly()
     {
         var edgeCaseScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("EdgeCase"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.EdgeCase));
 
         foreach (var scenario in edgeCaseScenarios)
         {
@@ -104,7 +104,7 @@ public async Task EndToEnd_EdgeCaseScenarios_HandleCorrectly()
     public async Task EndToEnd_SiteFilteringScenarios_FilterCorrectly()
     {
         var siteFilteringScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("SiteFiltering"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.SiteFiltering));
 
         foreach (var scenario in siteFilteringScenarios)
         {
@@ -141,7 +141,7 @@ public async Task EndToEnd_SiteFilteringScenarios_FilterCorrectly()
     public async Task EndToEnd_TechnicalQueries_ReturnRelevantResults()
     {
         var technicalScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("Technical"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.Technical));
 
         foreach (var scenario in technicalScenarios)
         {
diff --git a/tests/NLWebNet.Tests/Services/ToolSelectionAccuracyTests.cs b/tests/NLWebNet.Tests/Services/ToolSelectionAccuracyTests.cs
@@ -46,7 +46,7 @@ public void Cleanup()
     public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()
     {
         var compareScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("Compare"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.Compare));
 
         foreach (var scenario in compareScenarios)
         {
@@ -57,10 +57,10 @@ public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()
 
             Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");
 
-            if (scenario.ExpectedTools.Contains("Compare"))
+            if (scenario.ExpectedTools.Contains(TestConstants.Tools.Compare))
             {
                 // For compare scenarios, the tool selector should select the "compare" tool
-                Assert.AreEqual("compare", selectedTool?.ToLowerInvariant(),
+                Assert.AreEqual(ToolSelector.ToolConstants.CompareTool, selectedTool?.ToLowerInvariant(),
                     $"Expected 'compare' tool to be selected for compare query: '{scenario.Query}'");
                 Console.WriteLine($"✓ Compare tool correctly selected for: {scenario.Query}");
             }
@@ -80,7 +80,7 @@ public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()
     public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()
     {
         var detailScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("Details"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.Details));
 
         foreach (var scenario in detailScenarios)
         {
@@ -91,7 +91,7 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()
 
             Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");
 
-            if (scenario.ExpectedTools.Contains("Details"))
+            if (scenario.ExpectedTools.Contains(TestConstants.Tools.Details))
             {
                 // Check if the query actually contains details keywords that the tool selector recognizes
                 var queryLower = scenario.Query.ToLowerInvariant();
@@ -100,14 +100,14 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()
 
                 if (shouldSelectDetails)
                 {
-                    Assert.AreEqual("details", selectedTool?.ToLowerInvariant(),
+                    Assert.AreEqual(ToolSelector.ToolConstants.DetailsTool, selectedTool?.ToLowerInvariant(),
                         $"Expected 'details' tool to be selected for details query: '{scenario.Query}'");
                     Console.WriteLine($"✓ Details tool correctly selected for: {scenario.Query}");
                 }
                 else
                 {
                     // Query doesn't contain details keywords, so it defaults to search
-                    Assert.AreEqual("search", selectedTool?.ToLowerInvariant(),
+                    Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, selectedTool?.ToLowerInvariant(),
                         $"Expected 'search' tool (default) for query without details keywords: '{scenario.Query}'");
                     Console.WriteLine($"✓ Search tool (default) correctly selected for: {scenario.Query}");
                 }
@@ -128,7 +128,7 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()
     public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()
     {
         var ensembleScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("Ensemble"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.Ensemble));
 
         foreach (var scenario in ensembleScenarios)
         {
@@ -140,7 +140,7 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()
             Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");
 
             // Ensemble queries should be handled appropriately
-            if (scenario.ExpectedTools.Contains("Ensemble"))
+            if (scenario.ExpectedTools.Contains(TestConstants.Tools.Ensemble))
             {
                 // Check if the query actually contains ensemble keywords that the tool selector recognizes
                 var queryLower = scenario.Query.ToLowerInvariant();
@@ -149,14 +149,14 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()
 
                 if (shouldSelectEnsemble)
                 {
-                    Assert.AreEqual("ensemble", selectedTool?.ToLowerInvariant(),
+                    Assert.AreEqual(ToolSelector.ToolConstants.EnsembleTool, selectedTool?.ToLowerInvariant(),
                         $"Expected 'ensemble' tool to be selected for ensemble query: '{scenario.Query}'");
                     Console.WriteLine($"✓ Ensemble tool correctly selected for: {scenario.Query}");
                 }
                 else
                 {
                     // Query doesn't contain ensemble keywords, so it defaults to search
-                    Assert.AreEqual("search", selectedTool?.ToLowerInvariant(),
+                    Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, selectedTool?.ToLowerInvariant(),
                         $"Expected 'search' tool (default) for query without ensemble keywords: '{scenario.Query}'");
                     Console.WriteLine($"✓ Search tool (default) correctly selected for: {scenario.Query}");
                 }
@@ -177,7 +177,7 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()
     public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()
     {
         var basicSearchScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("BasicSearch"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.BasicSearch));
 
         foreach (var scenario in basicSearchScenarios)
         {
@@ -190,10 +190,10 @@ public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()
 
             // Basic search may or may not require specific tool selection
             // The important thing is that the selector doesn't crash and returns a valid response
-            if (scenario.ExpectedTools.Contains("Search"))
+            if (scenario.ExpectedTools.Contains(TestConstants.Tools.Search))
             {
                 // For basic search scenarios, the tool selector should select the "search" tool or null
-                Assert.IsTrue(selectedTool?.ToLowerInvariant() == "search" || selectedTool == null,
+                Assert.IsTrue(selectedTool?.ToLowerInvariant() == ToolSelector.ToolConstants.SearchTool || selectedTool == null,
                     $"Expected 'search' tool or null to be selected for basic search query: '{scenario.Query}', but got: {selectedTool}");
                 Console.WriteLine($"✓ Basic search tool selection validated: {selectedTool ?? "null"} for '{scenario.Query}'");
             }
@@ -212,7 +212,7 @@ public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()
     public async Task ToolSelection_EdgeCases_HandleGracefully()
     {
         var edgeCaseScenarios = TestDataManager.GetTestScenarios()
-            .Where(s => s.TestCategories.Contains("EdgeCase"));
+            .Where(s => s.TestCategories.Contains(TestConstants.Categories.EdgeCase));
 
         foreach (var scenario in edgeCaseScenarios)
         {
diff --git a/tests/NLWebNet.Tests/Services/ToolSelectorTests.cs b/tests/NLWebNet.Tests/Services/ToolSelectorTests.cs
@@ -124,7 +124,7 @@ public async Task SelectToolAsync_WhenSearchKeywords_ReturnsSearchTool()
         var result = await _toolSelector.SelectToolAsync(request);
 
         // Assert
-        Assert.AreEqual("search", result);
+        Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, result);
     }
 
     [TestMethod]
@@ -141,7 +141,7 @@ public async Task SelectToolAsync_WhenCompareKeywords_ReturnsCompareTool()
         var result = await _toolSelector.SelectToolAsync(request);
 
         // Assert
-        Assert.AreEqual("compare", result);
+        Assert.AreEqual(ToolSelector.ToolConstants.CompareTool, result);
     }
 
     [TestMethod]
@@ -158,7 +158,7 @@ public async Task SelectToolAsync_WhenDetailsKeywords_ReturnsDetailsTool()
         var result = await _toolSelector.SelectToolAsync(request);
 
         // Assert
-        Assert.AreEqual("details", result);
+        Assert.AreEqual(ToolSelector.ToolConstants.DetailsTool, result);
     }
 
     [TestMethod]
@@ -175,7 +175,7 @@ public async Task SelectToolAsync_WhenEnsembleKeywords_ReturnsEnsembleTool()
         var result = await _toolSelector.SelectToolAsync(request);
 
         // Assert
-        Assert.AreEqual("ensemble", result);
+        Assert.AreEqual(ToolSelector.ToolConstants.EnsembleTool, result);
     }
 
     [TestMethod]
@@ -192,6 +192,6 @@ public async Task SelectToolAsync_WhenGeneralQuery_ReturnsSearchTool()
         var result = await _toolSelector.SelectToolAsync(request);
 
         // Assert
-        Assert.AreEqual("search", result);
+        Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, result);
     }
 }
diff --git a/tests/NLWebNet.Tests/TestData/TestConstants.cs b/tests/NLWebNet.Tests/TestData/TestConstants.cs
@@ -0,0 +1,36 @@
+namespace NLWebNet.Tests.TestData;
+
+/// <summary>
+/// Constants for test data to avoid magic strings and ensure consistency
+/// </summary>
+public static class TestConstants
+{
+    /// <summary>
+    /// Tool names used in test scenarios (capitalized versions for test data)
+    /// </summary>
+    public static class Tools
+    {
+        public const string Search = "Search";
+        public const string Compare = "Compare";
+        public const string Details = "Details";
+        public const string Ensemble = "Ensemble";
+    }
+
+    /// <summary>
+    /// Test categories used to group and filter test scenarios
+    /// </summary>
+    public static class Categories
+    {
+        public const string BasicSearch = "BasicSearch";
+        public const string Technical = "Technical";
+        public const string Compare = "Compare";
+        public const string Details = "Details";
+        public const string Ensemble = "Ensemble";
+        public const string EdgeCase = "EdgeCase";
+        public const string SiteFiltering = "SiteFiltering";
+        public const string EndToEnd = "EndToEnd";
+        public const string ToolSelection = "ToolSelection";
+        public const string Complex = "Complex";
+        public const string Validation = "Validation";
+    }
+}
diff --git a/tests/NLWebNet.Tests/TestData/TestDataManager.cs b/tests/NLWebNet.Tests/TestData/TestDataManager.cs
@@ -19,9 +19,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Description = "Simple search query testing basic functionality",
             Query = "millennium falcon",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Search" },
+            ExpectedTools = new[] { TestConstants.Tools.Search },
             MinExpectedResults = 1,
-            TestCategories = new[] { "BasicSearch", "EndToEnd" }
+            TestCategories = new[] { TestConstants.Categories.BasicSearch, TestConstants.Categories.EndToEnd }
         };
 
         yield return new TestScenario
@@ -30,9 +30,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Description = "Query for technical documentation or API information",
             Query = "API documentation for web services",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Search", "Details" },
+            ExpectedTools = new[] { TestConstants.Tools.Search, TestConstants.Tools.Details },
             MinExpectedResults = 1,
-            TestCategories = new[] { "Technical", "EndToEnd" }
+            TestCategories = new[] { TestConstants.Categories.Technical, TestConstants.Categories.EndToEnd }
         };
 
         yield return new TestScenario
@@ -41,9 +41,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Description = "Comparative query that should trigger compare tool",
             Query = "compare .NET Core vs .NET Framework",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Compare", "Search" },
+            ExpectedTools = new[] { TestConstants.Tools.Compare, TestConstants.Tools.Search },
             MinExpectedResults = 1,
-            TestCategories = new[] { "Compare", "ToolSelection" }
+            TestCategories = new[] { TestConstants.Categories.Compare, TestConstants.Categories.ToolSelection }
         };
 
         yield return new TestScenario
@@ -52,9 +52,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Description = "Specific detail query for detailed information",
             Query = "detailed specifications for Enterprise NX-01",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Details", "Search" },
+            ExpectedTools = new[] { TestConstants.Tools.Details, TestConstants.Tools.Search },
             MinExpectedResults = 1,
-            TestCategories = new[] { "Details", "ToolSelection" }
+            TestCategories = new[] { TestConstants.Categories.Details, TestConstants.Categories.ToolSelection }
         };
 
         yield return new TestScenario
@@ -63,9 +63,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Description = "Complex query requiring ensemble of tools",
             Query = "comprehensive analysis of space exploration technologies",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Ensemble", "Search", "Compare" },
+            ExpectedTools = new[] { TestConstants.Tools.Ensemble, TestConstants.Tools.Search, TestConstants.Tools.Compare },
             MinExpectedResults = 2,
-            TestCategories = new[] { "Ensemble", "Complex" }
+            TestCategories = new[] { TestConstants.Categories.Ensemble, TestConstants.Categories.Complex }
         };
 
         yield return new TestScenario
@@ -76,7 +76,7 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             ExpectedMode = QueryMode.List,
             ExpectedTools = Array.Empty<string>(),
             MinExpectedResults = 0,
-            TestCategories = new[] { "EdgeCase", "Validation" }
+            TestCategories = new[] { TestConstants.Categories.EdgeCase, TestConstants.Categories.Validation }
         };
 
         yield return new TestScenario
@@ -86,9 +86,9 @@ public static IEnumerable<TestScenario> GetTestScenarios()
             Query = "Dune movie",
             Site = "scifi-cinema.com",
             ExpectedMode = QueryMode.List,
-            ExpectedTools = new[] { "Search" },
+            ExpectedTools = new[] { TestConstants.Tools.Search },
             MinExpectedResults = 1,
-            TestCategories = new[] { "SiteFiltering", "EndToEnd" }
+            TestCategories = new[] { TestConstants.Categories.SiteFiltering, TestConstants.Categories.EndToEnd }
         };
     }
 

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class ToolSelector : IToolSelector`
`15`	`15`	`/// <summary>`
`16`	`16`	`/// Constants for tool names and associated keywords`
`17`	`17`	`/// </summary>`
`18`		`- private static class ToolConstants`
	`18`	`+ public static class ToolConstants`
`19`	`19`	`{`
`20`	`20`	`// Tool names`
`21`	`21`	`public const string SearchTool = "search";`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public void Cleanup()`
`45`	`45`	`public async Task EndToEnd_BasicSearchScenarios_AllPass()`
`46`	`46`	`{`
`47`	`47`	`var basicSearchScenarios = TestDataManager.GetTestScenarios()`
`48`		`- .Where(s => s.TestCategories.Contains("BasicSearch"));`
	`48`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.BasicSearch));`
`49`	`49`
`50`	`50`	`foreach (var scenario in basicSearchScenarios)`
`51`	`51`	`{`
`@@ -78,7 +78,7 @@ public async Task EndToEnd_BasicSearchScenarios_AllPass()`
`78`	`78`	`public async Task EndToEnd_EdgeCaseScenarios_HandleCorrectly()`
`79`	`79`	`{`
`80`	`80`	`var edgeCaseScenarios = TestDataManager.GetTestScenarios()`
`81`		`- .Where(s => s.TestCategories.Contains("EdgeCase"));`
	`81`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.EdgeCase));`
`82`	`82`
`83`	`83`	`foreach (var scenario in edgeCaseScenarios)`
`84`	`84`	`{`
`@@ -104,7 +104,7 @@ public async Task EndToEnd_EdgeCaseScenarios_HandleCorrectly()`
`104`	`104`	`public async Task EndToEnd_SiteFilteringScenarios_FilterCorrectly()`
`105`	`105`	`{`
`106`	`106`	`var siteFilteringScenarios = TestDataManager.GetTestScenarios()`
`107`		`- .Where(s => s.TestCategories.Contains("SiteFiltering"));`
	`107`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.SiteFiltering));`
`108`	`108`
`109`	`109`	`foreach (var scenario in siteFilteringScenarios)`
`110`	`110`	`{`
`@@ -141,7 +141,7 @@ public async Task EndToEnd_SiteFilteringScenarios_FilterCorrectly()`
`141`	`141`	`public async Task EndToEnd_TechnicalQueries_ReturnRelevantResults()`
`142`	`142`	`{`
`143`	`143`	`var technicalScenarios = TestDataManager.GetTestScenarios()`
`144`		`- .Where(s => s.TestCategories.Contains("Technical"));`
	`144`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.Technical));`
`145`	`145`
`146`	`146`	`foreach (var scenario in technicalScenarios)`
`147`	`147`	`{`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public void Cleanup()`
`46`	`46`	`public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()`
`47`	`47`	`{`
`48`	`48`	`var compareScenarios = TestDataManager.GetTestScenarios()`
`49`		`- .Where(s => s.TestCategories.Contains("Compare"));`
	`49`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.Compare));`
`50`	`50`
`51`	`51`	`foreach (var scenario in compareScenarios)`
`52`	`52`	`{`
`@@ -57,10 +57,10 @@ public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()`
`57`	`57`
`58`	`58`	`Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");`
`59`	`59`
`60`		`- if (scenario.ExpectedTools.Contains("Compare"))`
	`60`	`+ if (scenario.ExpectedTools.Contains(TestConstants.Tools.Compare))`
`61`	`61`	`{`
`62`	`62`	`// For compare scenarios, the tool selector should select the "compare" tool`
`63`		`- Assert.AreEqual("compare", selectedTool?.ToLowerInvariant(),`
	`63`	`+ Assert.AreEqual(ToolSelector.ToolConstants.CompareTool, selectedTool?.ToLowerInvariant(),`
`64`	`64`	`$"Expected 'compare' tool to be selected for compare query: '{scenario.Query}'");`
`65`	`65`	`Console.WriteLine($"✓ Compare tool correctly selected for: {scenario.Query}");`
`66`	`66`	`}`
`@@ -80,7 +80,7 @@ public async Task ToolSelection_CompareQueries_SelectCompareToolCorrectly()`
`80`	`80`	`public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()`
`81`	`81`	`{`
`82`	`82`	`var detailScenarios = TestDataManager.GetTestScenarios()`
`83`		`- .Where(s => s.TestCategories.Contains("Details"));`
	`83`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.Details));`
`84`	`84`
`85`	`85`	`foreach (var scenario in detailScenarios)`
`86`	`86`	`{`
`@@ -91,7 +91,7 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()`
`91`	`91`
`92`	`92`	`Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");`
`93`	`93`
`94`		`- if (scenario.ExpectedTools.Contains("Details"))`
	`94`	`+ if (scenario.ExpectedTools.Contains(TestConstants.Tools.Details))`
`95`	`95`	`{`
`96`	`96`	`// Check if the query actually contains details keywords that the tool selector recognizes`
`97`	`97`	`var queryLower = scenario.Query.ToLowerInvariant();`
`@@ -100,14 +100,14 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()`
`100`	`100`
`101`	`101`	`if (shouldSelectDetails)`
`102`	`102`	`{`
`103`		`- Assert.AreEqual("details", selectedTool?.ToLowerInvariant(),`
	`103`	`+ Assert.AreEqual(ToolSelector.ToolConstants.DetailsTool, selectedTool?.ToLowerInvariant(),`
`104`	`104`	`$"Expected 'details' tool to be selected for details query: '{scenario.Query}'");`
`105`	`105`	`Console.WriteLine($"✓ Details tool correctly selected for: {scenario.Query}");`
`106`	`106`	`}`
`107`	`107`	`else`
`108`	`108`	`{`
`109`	`109`	`// Query doesn't contain details keywords, so it defaults to search`
`110`		`- Assert.AreEqual("search", selectedTool?.ToLowerInvariant(),`
	`110`	`+ Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, selectedTool?.ToLowerInvariant(),`
`111`	`111`	`$"Expected 'search' tool (default) for query without details keywords: '{scenario.Query}'");`
`112`	`112`	`Console.WriteLine($"✓ Search tool (default) correctly selected for: {scenario.Query}");`
`113`	`113`	`}`
`@@ -128,7 +128,7 @@ public async Task ToolSelection_DetailQueries_SelectDetailsToolCorrectly()`
`128`	`128`	`public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()`
`129`	`129`	`{`
`130`	`130`	`var ensembleScenarios = TestDataManager.GetTestScenarios()`
`131`		`- .Where(s => s.TestCategories.Contains("Ensemble"));`
	`131`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.Ensemble));`
`132`	`132`
`133`	`133`	`foreach (var scenario in ensembleScenarios)`
`134`	`134`	`{`
`@@ -140,7 +140,7 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()`
`140`	`140`	`Console.WriteLine($"Selected tool: {selectedTool ?? "None"}");`
`141`	`141`
`142`	`142`	`// Ensemble queries should be handled appropriately`
`143`		`- if (scenario.ExpectedTools.Contains("Ensemble"))`
	`143`	`+ if (scenario.ExpectedTools.Contains(TestConstants.Tools.Ensemble))`
`144`	`144`	`{`
`145`	`145`	`// Check if the query actually contains ensemble keywords that the tool selector recognizes`
`146`	`146`	`var queryLower = scenario.Query.ToLowerInvariant();`
`@@ -149,14 +149,14 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()`
`149`	`149`
`150`	`150`	`if (shouldSelectEnsemble)`
`151`	`151`	`{`
`152`		`- Assert.AreEqual("ensemble", selectedTool?.ToLowerInvariant(),`
	`152`	`+ Assert.AreEqual(ToolSelector.ToolConstants.EnsembleTool, selectedTool?.ToLowerInvariant(),`
`153`	`153`	`$"Expected 'ensemble' tool to be selected for ensemble query: '{scenario.Query}'");`
`154`	`154`	`Console.WriteLine($"✓ Ensemble tool correctly selected for: {scenario.Query}");`
`155`	`155`	`}`
`156`	`156`	`else`
`157`	`157`	`{`
`158`	`158`	`// Query doesn't contain ensemble keywords, so it defaults to search`
`159`		`- Assert.AreEqual("search", selectedTool?.ToLowerInvariant(),`
	`159`	`+ Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, selectedTool?.ToLowerInvariant(),`
`160`	`160`	`$"Expected 'search' tool (default) for query without ensemble keywords: '{scenario.Query}'");`
`161`	`161`	`Console.WriteLine($"✓ Search tool (default) correctly selected for: {scenario.Query}");`
`162`	`162`	`}`
`@@ -177,7 +177,7 @@ public async Task ToolSelection_EnsembleQueries_SelectToolsCorrectly()`
`177`	`177`	`public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()`
`178`	`178`	`{`
`179`	`179`	`var basicSearchScenarios = TestDataManager.GetTestScenarios()`
`180`		`- .Where(s => s.TestCategories.Contains("BasicSearch"));`
	`180`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.BasicSearch));`
`181`	`181`
`182`	`182`	`foreach (var scenario in basicSearchScenarios)`
`183`	`183`	`{`
`@@ -190,10 +190,10 @@ public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()`
`190`	`190`
`191`	`191`	`// Basic search may or may not require specific tool selection`
`192`	`192`	`// The important thing is that the selector doesn't crash and returns a valid response`
`193`		`- if (scenario.ExpectedTools.Contains("Search"))`
	`193`	`+ if (scenario.ExpectedTools.Contains(TestConstants.Tools.Search))`
`194`	`194`	`{`
`195`	`195`	`// For basic search scenarios, the tool selector should select the "search" tool or null`
`196`		`- Assert.IsTrue(selectedTool?.ToLowerInvariant() == "search" \|\| selectedTool == null,`
	`196`	`+ Assert.IsTrue(selectedTool?.ToLowerInvariant() == ToolSelector.ToolConstants.SearchTool \|\| selectedTool == null,`
`197`	`197`	`$"Expected 'search' tool or null to be selected for basic search query: '{scenario.Query}', but got: {selectedTool}");`
`198`	`198`	`Console.WriteLine($"✓ Basic search tool selection validated: {selectedTool ?? "null"} for '{scenario.Query}'");`
`199`	`199`	`}`
`@@ -212,7 +212,7 @@ public async Task ToolSelection_BasicSearchQueries_HandleAppropriately()`
`212`	`212`	`public async Task ToolSelection_EdgeCases_HandleGracefully()`
`213`	`213`	`{`
`214`	`214`	`var edgeCaseScenarios = TestDataManager.GetTestScenarios()`
`215`		`- .Where(s => s.TestCategories.Contains("EdgeCase"));`
	`215`	`+ .Where(s => s.TestCategories.Contains(TestConstants.Categories.EdgeCase));`
`216`	`216`
`217`	`217`	`foreach (var scenario in edgeCaseScenarios)`
`218`	`218`	`{`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ public async Task SelectToolAsync_WhenSearchKeywords_ReturnsSearchTool()`
`124`	`124`	`var result = await _toolSelector.SelectToolAsync(request);`
`125`	`125`
`126`	`126`	`// Assert`
`127`		`- Assert.AreEqual("search", result);`
	`127`	`+ Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, result);`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`[TestMethod]`
`@@ -141,7 +141,7 @@ public async Task SelectToolAsync_WhenCompareKeywords_ReturnsCompareTool()`
`141`	`141`	`var result = await _toolSelector.SelectToolAsync(request);`
`142`	`142`
`143`	`143`	`// Assert`
`144`		`- Assert.AreEqual("compare", result);`
	`144`	`+ Assert.AreEqual(ToolSelector.ToolConstants.CompareTool, result);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`[TestMethod]`
`@@ -158,7 +158,7 @@ public async Task SelectToolAsync_WhenDetailsKeywords_ReturnsDetailsTool()`
`158`	`158`	`var result = await _toolSelector.SelectToolAsync(request);`
`159`	`159`
`160`	`160`	`// Assert`
`161`		`- Assert.AreEqual("details", result);`
	`161`	`+ Assert.AreEqual(ToolSelector.ToolConstants.DetailsTool, result);`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`[TestMethod]`
`@@ -175,7 +175,7 @@ public async Task SelectToolAsync_WhenEnsembleKeywords_ReturnsEnsembleTool()`
`175`	`175`	`var result = await _toolSelector.SelectToolAsync(request);`
`176`	`176`
`177`	`177`	`// Assert`
`178`		`- Assert.AreEqual("ensemble", result);`
	`178`	`+ Assert.AreEqual(ToolSelector.ToolConstants.EnsembleTool, result);`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`[TestMethod]`
`@@ -192,6 +192,6 @@ public async Task SelectToolAsync_WhenGeneralQuery_ReturnsSearchTool()`
`192`	`192`	`var result = await _toolSelector.SelectToolAsync(request);`
`193`	`193`
`194`	`194`	`// Assert`
`195`		`- Assert.AreEqual("search", result);`
	`195`	`+ Assert.AreEqual(ToolSelector.ToolConstants.SearchTool, result);`
`196`	`196`	`}`
`197`	`197`	`}`