style: fix Ruff lint errors and apply Black formatting

- Combine nested with statements using parenthesized context managers
- Remove unused variable assignment in test_schema.py
- Apply Black formatting to all test files

Fixes SIM117 (nested with) and F841 (unused variable) lint errors.

Author: Sakeeb91

tests/conftest.py

@@ -21,8 +21,7 @@
 from app.config import Settings
 from app.main import app
 from db.connection import DatabaseManager
-from db.schema import SchemaInfo, TableInfo, ColumnInfo
-
+from db.schema import ColumnInfo, SchemaInfo, TableInfo
 
 # =============================================================================
 # Configuration Fixtures

tests/integration/test_api.py

@@ -2,7 +2,6 @@
 Integration tests for API endpoints.
 """
 
-import pytest
 from fastapi.testclient import TestClient
 
 

tests/integration/test_database.py

@@ -11,8 +11,8 @@
 from sqlalchemy.pool import StaticPool
 
 from db.connection import DatabaseManager
+from db.executor import SafeQueryExecutor
 from db.schema import SchemaIntrospector, get_sample_data
-from db.executor import SafeQueryExecutor, QueryResult
 
 
 @pytest.fixture

tests/unit/test_config.py

@@ -6,10 +6,9 @@
 from pydantic import ValidationError
 
 from app.config import (
-    APISettings,
     AgentSettings,
+    APISettings,
     DatabaseSettings,
-    HuggingFaceSettings,
     Settings,
     get_settings,
 )

tests/unit/test_connection.py

@@ -2,17 +2,17 @@
 Unit tests for database connection management.
 """
 
-import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
 
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+import pytest
+from sqlalchemy.ext.asyncio import AsyncEngine
 
 from app.exceptions import DatabaseConnectionException
 from db.connection import (
     DatabaseManager,
     _get_async_url,
-    get_database,
     close_database,
+    get_database,
 )
 
 
@@ -110,48 +110,54 @@ def test_dialect_property(self, mock_settings: MagicMock) -> None:
     @pytest.mark.asyncio
     async def test_initialize_success(self, mock_settings: MagicMock) -> None:
         """Test successful database initialization."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch("db.connection.create_async_engine") as mock_engine:
-                mock_engine.return_value = MagicMock(spec=AsyncEngine)
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch("db.connection.create_async_engine") as mock_engine,
+        ):
+            mock_engine.return_value = MagicMock(spec=AsyncEngine)
 
-                manager = DatabaseManager(url="sqlite:///test.db")
-                await manager.initialize()
+            manager = DatabaseManager(url="sqlite:///test.db")
+            await manager.initialize()
 
-                assert manager._is_initialized is True
-                assert manager._engine is not None
-                mock_engine.assert_called_once()
+            assert manager._is_initialized is True
+            assert manager._engine is not None
+            mock_engine.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_initialize_already_initialized(
         self, mock_settings: MagicMock
     ) -> None:
         """Test that initialize is idempotent."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch("db.connection.create_async_engine") as mock_engine:
-                mock_engine.return_value = MagicMock(spec=AsyncEngine)
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch("db.connection.create_async_engine") as mock_engine,
+        ):
+            mock_engine.return_value = MagicMock(spec=AsyncEngine)
 
-                manager = DatabaseManager(url="sqlite:///test.db")
-                await manager.initialize()
-                await manager.initialize()  # Second call should be no-op
+            manager = DatabaseManager(url="sqlite:///test.db")
+            await manager.initialize()
+            await manager.initialize()  # Second call should be no-op
 
-                # Should only be called once
-                assert mock_engine.call_count == 1
+            # Should only be called once
+            assert mock_engine.call_count == 1
 
     @pytest.mark.asyncio
     async def test_initialize_failure(self, mock_settings: MagicMock) -> None:
         """Test database initialization failure."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch(
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch(
                 "db.connection.create_async_engine",
                 side_effect=Exception("Connection failed"),
-            ):
-                manager = DatabaseManager(url="sqlite:///test.db")
+            ),
+        ):
+            manager = DatabaseManager(url="sqlite:///test.db")
 
-                with pytest.raises(DatabaseConnectionException) as exc_info:
-                    await manager.initialize()
+            with pytest.raises(DatabaseConnectionException) as exc_info:
+                await manager.initialize()
 
-                assert "Failed to initialize database" in str(exc_info.value.message)
-                assert manager._is_initialized is False
+            assert "Failed to initialize database" in str(exc_info.value.message)
+            assert manager._is_initialized is False
 
     @pytest.mark.asyncio
     async def test_close(self, mock_settings: MagicMock) -> None:
@@ -221,44 +227,50 @@ def reset_global_manager(self) -> None:
     @pytest.mark.asyncio
     async def test_get_database_creates_manager(self, mock_settings: MagicMock) -> None:
         """Test get_database creates and initializes manager."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch("db.connection.create_async_engine") as mock_engine:
-                mock_engine.return_value = MagicMock(spec=AsyncEngine)
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch("db.connection.create_async_engine") as mock_engine,
+        ):
+            mock_engine.return_value = MagicMock(spec=AsyncEngine)
 
-                manager = await get_database()
+            manager = await get_database()
 
-                assert manager is not None
-                assert manager._is_initialized is True
+            assert manager is not None
+            assert manager._is_initialized is True
 
     @pytest.mark.asyncio
     async def test_get_database_returns_same_instance(
         self, mock_settings: MagicMock
     ) -> None:
         """Test get_database returns the same instance."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch("db.connection.create_async_engine") as mock_engine:
-                mock_engine.return_value = MagicMock(spec=AsyncEngine)
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch("db.connection.create_async_engine") as mock_engine,
+        ):
+            mock_engine.return_value = MagicMock(spec=AsyncEngine)
 
-                manager1 = await get_database()
-                manager2 = await get_database()
+            manager1 = await get_database()
+            manager2 = await get_database()
 
-                assert manager1 is manager2
+            assert manager1 is manager2
 
     @pytest.mark.asyncio
     async def test_close_database(self, mock_settings: MagicMock) -> None:
         """Test close_database closes the global manager."""
-        with patch("db.connection.get_settings", return_value=mock_settings):
-            with patch("db.connection.create_async_engine") as mock_engine:
-                mock_engine_instance = MagicMock(spec=AsyncEngine)
-                mock_engine_instance.dispose = AsyncMock()
-                mock_engine.return_value = mock_engine_instance
+        with (
+            patch("db.connection.get_settings", return_value=mock_settings),
+            patch("db.connection.create_async_engine") as mock_engine,
+        ):
+            mock_engine_instance = MagicMock(spec=AsyncEngine)
+            mock_engine_instance.dispose = AsyncMock()
+            mock_engine.return_value = mock_engine_instance
 
-                await get_database()
-                await close_database()
+            await get_database()
+            await close_database()
 
-                import db.connection
+            import db.connection
 
-                assert db.connection._db_manager is None
+            assert db.connection._db_manager is None
 
     @pytest.mark.asyncio
     async def test_close_database_when_not_initialized(self) -> None:

tests/unit/test_exceptions.py

@@ -2,8 +2,6 @@
 Unit tests for exception classes.
 """
 
-import pytest
-
 from app.exceptions import (
     AgentMaxStepsExceededException,
     AuthenticationException,

tests/unit/test_executor.py

@@ -3,24 +3,22 @@
 """
 
 import asyncio
-import pytest
-from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock
 
+import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.exceptions import (
     QueryExecutionException,
     QueryTimeoutException,
-    UnsupportedQueryTypeException,
 )
 from db.executor import (
+    DANGEROUS_KEYWORDS,
+    INJECTION_PATTERNS,
     QueryResult,
     QueryValidator,
     SafeQueryExecutor,
     sanitize_identifier,
-    DANGEROUS_KEYWORDS,
-    INJECTION_PATTERNS,
 )
 
 
@@ -391,7 +389,7 @@ def test_dangerous_keywords_coverage(self) -> None:
             "EXECUTE",
         }
 
-        assert DANGEROUS_KEYWORDS == expected_keywords
+        assert expected_keywords == DANGEROUS_KEYWORDS
 
     def test_injection_patterns_coverage(self) -> None:
         """Test that injection patterns cover common attacks."""

tests/unit/test_prompts.py

@@ -2,11 +2,9 @@
 Unit tests for prompt templates module.
 """
 
-import pytest
-
 from models.prompts import (
-    ArcticPromptTemplate,
     AgentPromptTemplate,
+    ArcticPromptTemplate,
     ChainOfThoughtPromptTemplate,
     FewShotExample,
     build_prompt,

tests/unit/test_schema.py

@@ -2,19 +2,18 @@
 Unit tests for database schema introspection utilities.
 """
 
-import pytest
-from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock
 
+import pytest
 from sqlalchemy.ext.asyncio import AsyncEngine
 
-from app.exceptions import SchemaNotFoundException, TableNotFoundException
+from app.exceptions import TableNotFoundException
 from db.schema import (
     ColumnInfo,
     ForeignKeyInfo,
-    TableInfo,
     SchemaInfo,
     SchemaIntrospector,
+    TableInfo,
     get_sample_data,
 )
 
@@ -262,7 +261,7 @@ async def test_get_schema_skips_cache_when_disabled(
         # Mock run_sync to return empty schema
         mock_connection.run_sync.return_value = {"tables": []}
 
-        result = await introspector.get_schema("test_db", use_cache=False)
+        await introspector.get_schema("test_db", use_cache=False)
 
         # Should have called connect (not used cache)
         mock_engine.connect.assert_called_once()