refactor(tests): migrate to connector-based tool naming

Update all test files to use connector-based naming conventions
(hibob_*, bamboohr_*, workday_*) instead of legacy unified API
naming (hris_*, ats_*, crm_*).

This ensures tests remain consistent with the updated examples and
reflect the actual tool naming used by StackOne connectors.

Affected tests:
- test_feedback.py
- test_meta_tools.py
- test_tfidf_index.py
- test_toolset.py

Author: ryoppippi

tests/test_feedback.py

@@ -252,7 +252,7 @@ def test_live_feedback_submission() -> None:
         {
             "feedback": f"CI live test feedback {feedback_token}",
             "account_id": f"acc-ci-{feedback_token}",
-            "tool_names": ["hris_list_employees"],
+            "tool_names": ["hibob_list_employees"],
         }
     )
 

tests/test_meta_tools.py

@@ -17,14 +17,14 @@ def sample_tools():
     """Create sample tools for testing"""
     tools = []
 
-    # Create HRIS tools
+    # Create HiBob tools
     for action in ["create", "list", "update", "delete"]:
         for entity in ["employee", "department", "timeoff"]:
-            tool_name = f"hris_{action}_{entity}"
+            tool_name = f"hibob_{action}_{entity}"
             execute_config = ExecuteConfig(
                 name=tool_name,
                 method="POST" if action in ["create", "update"] else "GET",
-                url=f"https://api.example.com/hris/{entity}",
+                url=f"https://api.example.com/hibob/{entity}",
                 headers={},
             )
 
@@ -37,21 +37,21 @@ def sample_tools():
             )
 
             tool = StackOneTool(
-                description=f"{action.capitalize()} {entity} in HRIS system",
+                description=f"{action.capitalize()} {entity} in HiBob system",
                 parameters=parameters,
                 _execute_config=execute_config,
                 _api_key="test_key",
             )
             tools.append(tool)
 
-    # Create ATS tools
+    # Create BambooHR tools
     for action in ["create", "list", "search"]:
         for entity in ["candidate", "job", "application"]:
-            tool_name = f"ats_{action}_{entity}"
+            tool_name = f"bamboohr_{action}_{entity}"
             execute_config = ExecuteConfig(
                 name=tool_name,
                 method="POST" if action == "create" else "GET",
-                url=f"https://api.example.com/ats/{entity}",
+                url=f"https://api.example.com/bamboohr/{entity}",
                 headers={},
             )
 
@@ -64,7 +64,7 @@ def sample_tools():
             )
 
             tool = StackOneTool(
-                description=f"{action.capitalize()} {entity} in ATS system",
+                description=f"{action.capitalize()} {entity} in BambooHR system",
                 parameters=parameters,
                 _execute_config=execute_config,
                 _api_key="test_key",
@@ -217,13 +217,13 @@ def test_execute_tool_call(self, tools_collection):
         with responses.RequestsMock() as rsps:
             rsps.add(
                 responses.GET,
-                "https://api.example.com/hris/employee",
+                "https://api.example.com/hibob/employee",
                 json={"success": True, "employees": []},
                 status=200,
             )
 
             # Call the meta execute tool
-            result = execute_tool.call(toolName="hris_list_employee", params={"limit": 10})
+            result = execute_tool.call(toolName="hibob_list_employee", params={"limit": 10})
 
             assert result is not None
             assert "success" in result or "employees" in result
@@ -288,14 +288,14 @@ def test_hybrid_search_returns_results(self, sample_tools):
         """Test that hybrid search returns meaningful results"""
         index = ToolIndex(sample_tools, hybrid_alpha=0.2)
         # Use more specific query to ensure we get employee tools
-        results = index.search("employee hris", limit=10)
+        results = index.search("employee hibob", limit=10)
 
         assert len(results) > 0
-        # Should find HRIS employee tools - check in broader result set
+        # Should find HiBob employee tools - check in broader result set
         result_names = [r.name for r in results]
-        # At least one result should contain "employee" or "hris"
-        assert any("employee" in name or "hris" in name for name in result_names), (
-            f"Expected 'employee' or 'hris' in results: {result_names}"
+        # At least one result should contain "employee" or "hibob"
+        assert any("employee" in name or "hibob" in name for name in result_names), (
+            f"Expected 'employee' or 'hibob' in results: {result_names}"
         )
 
     def test_hybrid_search_with_different_alphas(self, sample_tools):

tests/test_tfidf_index.py

@@ -44,9 +44,9 @@ def test_stopword_filtering(self):
 
     def test_underscore_preservation(self):
         """Test that underscores are preserved"""
-        text = "hris_list_employees"
+        text = "hibob_list_employees"
         tokens = tokenize(text)
-        assert "hris_list_employees" in tokens
+        assert "hibob_list_employees" in tokens
 
     def test_empty_string(self):
         """Test tokenization of empty string"""
@@ -279,17 +279,17 @@ def test_tool_name_matching(self):
         """Test matching tool names"""
         index = TfidfIndex()
         docs = [
-            TfidfDocument(id="hris_create_employee", text="create employee hris system"),
-            TfidfDocument(id="hris_list_employees", text="list employees hris system"),
-            TfidfDocument(id="ats_create_candidate", text="create candidate ats system"),
-            TfidfDocument(id="crm_list_contacts", text="list contacts crm system"),
+            TfidfDocument(id="hibob_create_employee", text="create employee hibob system"),
+            TfidfDocument(id="hibob_list_employees", text="list employees hibob system"),
+            TfidfDocument(id="bamboohr_create_candidate", text="create candidate bamboohr system"),
+            TfidfDocument(id="workday_list_contacts", text="list contacts workday system"),
         ]
         index.build(docs)
 
-        # Search for HRIS tools
-        results = index.search("employee hris", k=5)
+        # Search for HiBob tools
+        results = index.search("employee hibob", k=5)
         top_ids = [r.id for r in results[:2]]
-        assert "hris_create_employee" in top_ids or "hris_list_employees" in top_ids
+        assert "hibob_create_employee" in top_ids or "hibob_list_employees" in top_ids
 
         # Search for create operations
         results = index.search("create", k=5)

tests/test_toolset.py

@@ -18,58 +18,58 @@ def test_filter_by_provider():
     toolset = StackOneToolSet(api_key="test_key")
 
     # Test matching providers
-    assert toolset._filter_by_provider("hris_list_employees", ["hris", "ats"])
-    assert toolset._filter_by_provider("ats_create_job", ["hris", "ats"])
+    assert toolset._filter_by_provider("hibob_list_employees", ["hibob", "bamboohr"])
+    assert toolset._filter_by_provider("bamboohr_create_job", ["hibob", "bamboohr"])
 
     # Test non-matching providers
-    assert not toolset._filter_by_provider("crm_list_contacts", ["hris", "ats"])
+    assert not toolset._filter_by_provider("workday_list_contacts", ["hibob", "bamboohr"])
 
     # Test case-insensitive matching
-    assert toolset._filter_by_provider("HRIS_list_employees", ["hris"])
-    assert toolset._filter_by_provider("hris_list_employees", ["HRIS"])
+    assert toolset._filter_by_provider("HIBOB_list_employees", ["hibob"])
+    assert toolset._filter_by_provider("hibob_list_employees", ["HIBOB"])
 
 
 def test_filter_by_action():
     """Test action filtering with glob patterns"""
     toolset = StackOneToolSet(api_key="test_key")
 
     # Test exact match
-    assert toolset._filter_by_action("hris_list_employees", ["hris_list_employees"])
+    assert toolset._filter_by_action("hibob_list_employees", ["hibob_list_employees"])
 
     # Test glob pattern
-    assert toolset._filter_by_action("hris_list_employees", ["*_list_employees"])
-    assert toolset._filter_by_action("ats_list_employees", ["*_list_employees"])
-    assert toolset._filter_by_action("hris_list_employees", ["hris_*"])
-    assert toolset._filter_by_action("hris_create_employee", ["hris_*"])
+    assert toolset._filter_by_action("hibob_list_employees", ["*_list_employees"])
+    assert toolset._filter_by_action("bamboohr_list_employees", ["*_list_employees"])
+    assert toolset._filter_by_action("hibob_list_employees", ["hibob_*"])
+    assert toolset._filter_by_action("hibob_create_employee", ["hibob_*"])
 
     # Test non-matching patterns
-    assert not toolset._filter_by_action("crm_list_contacts", ["*_list_employees"])
-    assert not toolset._filter_by_action("ats_create_job", ["hris_*"])
+    assert not toolset._filter_by_action("workday_list_contacts", ["*_list_employees"])
+    assert not toolset._filter_by_action("bamboohr_create_job", ["hibob_*"])
 
 
 def test_matches_filter_positive_patterns():
     """Test _matches_filter with positive patterns"""
     toolset = StackOneToolSet(api_key="test_key")
 
     # Single pattern
-    assert toolset._matches_filter("hris_list_employees", "hris_*")
-    assert toolset._matches_filter("ats_create_job", "ats_*")
-    assert not toolset._matches_filter("crm_contacts", "hris_*")
+    assert toolset._matches_filter("hibob_list_employees", "hibob_*")
+    assert toolset._matches_filter("bamboohr_create_job", "bamboohr_*")
+    assert not toolset._matches_filter("workday_contacts", "hibob_*")
 
     # Multiple patterns (OR logic)
-    assert toolset._matches_filter("hris_list_employees", ["hris_*", "ats_*"])
-    assert toolset._matches_filter("ats_create_job", ["hris_*", "ats_*"])
-    assert not toolset._matches_filter("crm_contacts", ["hris_*", "ats_*"])
+    assert toolset._matches_filter("hibob_list_employees", ["hibob_*", "bamboohr_*"])
+    assert toolset._matches_filter("bamboohr_create_job", ["hibob_*", "bamboohr_*"])
+    assert not toolset._matches_filter("workday_contacts", ["hibob_*", "bamboohr_*"])
 
 
 def test_matches_filter_negative_patterns():
     """Test _matches_filter with negative patterns (exclusion)"""
     toolset = StackOneToolSet(api_key="test_key")
 
     # Negative pattern
-    assert not toolset._matches_filter("hris_delete_employee", ["hris_*", "!hris_delete_*"])
-    assert toolset._matches_filter("hris_list_employees", ["hris_*", "!hris_delete_*"])
+    assert not toolset._matches_filter("hibob_delete_employee", ["hibob_*", "!hibob_delete_*"])
+    assert toolset._matches_filter("hibob_list_employees", ["hibob_*", "!hibob_delete_*"])
 
     # Only negative patterns (should match everything not excluded)
-    assert not toolset._matches_filter("hris_delete_employee", "!hris_delete_*")
-    assert toolset._matches_filter("hris_list_employees", "!hris_delete_*")
+    assert not toolset._matches_filter("hibob_delete_employee", "!hibob_delete_*")
+    assert toolset._matches_filter("hibob_list_employees", "!hibob_delete_*")