chore: remove redundant test_3lo.py

anubhav756 · anubhav756 · commit 30bae1cae019 · 2025-12-11T02:37:29.000+05:30
diff --git a/packages/toolbox-adk/src/toolbox_adk/toolset.py b/packages/toolbox-adk/src/toolbox_adk/toolset.py
@@ -24,7 +24,6 @@
 from .tool import ToolboxContext, ToolboxTool
 
 
-
 class ToolboxToolset(BaseToolset):
     """
     A Toolset that provides tools from a remote Toolbox server.
diff --git a/packages/toolbox-adk/tests/integration/test_integration.py b/packages/toolbox-adk/tests/integration/test_integration.py
@@ -13,16 +13,23 @@
 # limitations under the License.
 
 
-from typing import Any, Optional
-import pytest
 import os
-from toolbox_adk import ToolboxToolset, CredentialStrategy, ToolboxTool
+from typing import Any, Optional
 from unittest.mock import MagicMock
-from google.adk.auth.auth_credential import AuthCredential, AuthCredentialTypes, OAuth2Auth
+
+import pytest
+from google.adk.auth.auth_credential import (
+    AuthCredential,
+    AuthCredentialTypes,
+    OAuth2Auth,
+)
+
+from toolbox_adk import CredentialStrategy, ToolboxTool, ToolboxToolset
 
 # Ensure TOOLBOX_VERSION is set for the fixture
 if "TOOLBOX_VERSION" not in os.environ:
-    os.environ["TOOLBOX_VERSION"] = "0.0.1" # Use a valid version or mock
+    os.environ["TOOLBOX_VERSION"] = "0.0.1"  # Use a valid version or mock
+
 
 @pytest.mark.asyncio
 @pytest.mark.usefixtures("toolbox_server")
@@ -35,58 +42,58 @@ class TestToolboxAdkIntegration:
     async def test_load_toolset_and_run(self):
         # We assume the toolbox server (started by fixture) is at localhost:5000 (default)
         # Auth: TOOLBOX_IDENTITY for simplicity in this local test as we don't have ADK identity setup.
-        
+
         toolset = ToolboxToolset(
             server_url="http://localhost:5000",
             toolset_name="my-toolset",
-            credentials=CredentialStrategy.TOOLBOX_IDENTITY()
+            credentials=CredentialStrategy.TOOLBOX_IDENTITY(),
         )
-        
+
         try:
             tools = await toolset.get_tools()
             assert len(tools) > 0
-            
+
             # Find 'get-row-by-id'
             tool = next((t for t in tools if t.name == "get-row-by-id"), None)
             assert tool is not None
             assert isinstance(tool, ToolboxTool)
-            
+
             # Run it
             # Mocking ToolContext as we are running directly
             ctx = MagicMock()
             result = await tool.run_async({"id": "1"}, ctx)
-            
+
             assert "row1" in result
-            
+
         finally:
             await toolset.close()
 
     async def test_partial_loading_by_names(self):
         toolset = ToolboxToolset(
             server_url="http://localhost:5000",
             tool_names=["get-n-rows"],
-            credentials=CredentialStrategy.TOOLBOX_IDENTITY()
+            credentials=CredentialStrategy.TOOLBOX_IDENTITY(),
         )
         try:
             tools = await toolset.get_tools()
             assert len(tools) == 1
             assert tools[0].name == "get-n-rows"
-            
+
             # Run it
             ctx = MagicMock()
             result = await tools[0].run_async({"num_rows": "1"}, ctx)
             assert "row1" in result
-            
+
         finally:
             await toolset.close()
-            
+
     async def test_bound_params_e2e(self):
         # Test binding param at toolset level
         toolset = ToolboxToolset(
             server_url="http://localhost:5000",
             tool_names=["get-n-rows"],
             bound_params={"num_rows": "2"},
-            credentials=CredentialStrategy.TOOLBOX_IDENTITY()
+            credentials=CredentialStrategy.TOOLBOX_IDENTITY(),
         )
         try:
             tools = await toolset.get_tools()
@@ -103,53 +110,54 @@ async def test_3lo_flow_simulation(self):
             server_url="http://localhost:5000",
             toolset_name="auth-test-toolset",
             credentials=CredentialStrategy.USER_IDENTITY(
-                client_id="test-client-id",
-                client_secret="test-client-secret"
-            )
+                client_id="test-client-id", client_secret="test-client-secret"
+            ),
         )
-        
+
         try:
             # 2. Get Tools (This hits the real server)
             # We filter for a simple tool if possible, or just take the first one.
             # We assume the fixture loads a manifest with at least one tool.
             tools = await toolset.get_tools()
             assert len(tools) > 0
-            
+
             # Pick a tool
             tool = tools[0]
             assert isinstance(tool, ToolboxTool)
-            
+
             # 3. Simulate First Call (No Credential)
             # Create a mock context that behaves like ADK's ReadonlyContext
             mock_ctx_first = MagicMock()
             # Simulate "No Auth Response Found"
             mock_ctx_first.get_auth_response.return_value = None
-            
+
             print("Running tool first time (expecting auth request)...")
             result_first = await tool.run_async({}, mock_ctx_first)
-            
+
             # 4. Verify Interruption
             # The wrapper should catch the missing creds and request them.
-            assert result_first is None, "Tool should return None to signal auth requirement"
+            assert (
+                result_first is None
+            ), "Tool should return None to signal auth requirement"
             mock_ctx_first.request_credential.assert_called_once()
-            
+
             # Inspect the requested config
             auth_config = mock_ctx_first.request_credential.call_args[0][0]
             assert auth_config.raw_auth_credential.oauth2.client_id == "test-client-id"
-            
+
             # 5. Simulate Runner Handling & Second Call (With Credential)
             # The runner would get the token. We simulate passing it back in context.
             mock_ctx_second = MagicMock()
-            
+
             # Simulate "Auth Response Found"
             mock_creds = AuthCredential(
                 auth_type=AuthCredentialTypes.OAUTH2,
-                oauth2=OAuth2Auth(access_token="fake-access-token")
+                oauth2=OAuth2Auth(access_token="fake-access-token"),
             )
             mock_ctx_second.get_auth_response.return_value = mock_creds
-            
+
             print("Running tool second time (expecting success or server error)...")
-            
+
             try:
                 result_second = await tool.run_async({}, mock_ctx_second)
                 assert result_second is not None
diff --git a/packages/toolbox-adk/tests/unit/test_3lo.py b/packages/toolbox-adk/tests/unit/test_3lo.py
diff --git a/packages/toolbox-adk/tests/unit/test_client.py b/packages/toolbox-adk/tests/unit/test_client.py
@@ -27,9 +27,7 @@ def test_init_no_auth(self, mock_core_client):
         creds = CredentialStrategy.TOOLBOX_IDENTITY()
         client = ToolboxClient("http://server", credentials=creds)
 
-        mock_core_client.assert_called_with(
-            url="http://server", client_headers={}
-        )
+        mock_core_client.assert_called_with(url="http://server", client_headers={})
 
     @patch("toolbox_adk.client.toolbox_core.ToolboxClient")
     def test_init_manual_token(self, mock_core_client):
@@ -172,45 +170,38 @@ async def test_delegation(self, mock_core_client):
     @patch("toolbox_adk.client.toolbox_core.ToolboxClient")
     def test_init_additional_headers_callable(self, mock_core_client):
         creds = CredentialStrategy.TOOLBOX_IDENTITY()
-        
+
         def my_header_provider():
             return "dynamic-val"
-            
-        headers = {
-            "X-Static": "static-val",
-            "X-Dynamic": my_header_provider
-        }
-        
+
+        headers = {"X-Static": "static-val", "X-Dynamic": my_header_provider}
+
         client = ToolboxClient(
-            "http://server",
-            credentials=creds,
-            additional_headers=headers
+            "http://server", credentials=creds, additional_headers=headers
         )
-        
+
         mock_core_client.assert_called_with(
             url="http://server",
-            client_headers={
-                "X-Static": "static-val",
-                "X-Dynamic": my_header_provider
-            }
+            client_headers={"X-Static": "static-val", "X-Dynamic": my_header_provider},
         )
-        
+
     @patch("toolbox_adk.client.toolbox_core.ToolboxClient")
     def test_close_calls_client_close(self, mock_core_client):
         # Coverage for close()
         mock_instance = mock_core_client.return_value
         # Make close an async mock
         mock_instance.close = AsyncMock()
-        
+
         client = ToolboxClient("http://server")
-        
+
         import asyncio
+
         loop = asyncio.new_event_loop()
         loop.run_until_complete(client.close())
         loop.close()
-        
+
         mock_instance.close.assert_called_once()
-        
+
     @patch("toolbox_adk.client.toolbox_core.ToolboxClient")
     def test_credential_config_property(self, mock_core_client):
         # Coverage for credential_config property
@@ -224,9 +215,9 @@ async def test_load_tool_delegates(self, mock_core_client):
         # Coverage for load_tool()
         mock_instance = mock_core_client.return_value
         mock_instance.load_tool = AsyncMock(return_value="tool_result")
-        
+
         client = ToolboxClient("http://server")
         result = await client.load_tool("my-tool", arg="val")
-        
+
         assert result == "tool_result"
         mock_instance.load_tool.assert_called_with("my-tool", arg="val")
diff --git a/packages/toolbox-adk/tests/unit/test_toolset.py b/packages/toolbox-adk/tests/unit/test_toolset.py
@@ -20,7 +20,6 @@
 from toolbox_adk.toolset import ToolboxToolset
 
 
-
 class TestToolboxToolset:
 
     @patch("toolbox_adk.toolset.ToolboxClient")
