diff_conftest.patch

diff --git a/tests/conftest.py b/tests/conftest.py
index d182d2ef..dc90fda8 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,234 +1,250 @@
 """
 Test configuration and fixtures for ICC Rule Engine
 """
 import os
 import asyncio
 import pytest
 import pytest_asyncio
 import tempfile
 from typing import Generator
+from uuid import uuid4
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from fastapi.testclient import TestClient
 
 # Set test environment variables
 os.environ["DATABASE_URL"] = "sqlite:///./test_icc_rules.db"
 os.environ["OPENAI_API_KEY"] = ""  # Disable LLM for most tests
 os.environ["REDIS_URL"] = ""  # Disable Redis for most tests
 os.environ["METRICS_ENABLED"] = "false"
 os.environ["LOGGING_ENABLED"] = "false"
 os.environ["MULTI_TENANT_ENABLED"] = "true"
-os.environ["DEMO_MODE"] = "true"
+os.environ["DEMO_MODE"] = "false"
 os.environ["API_KEY_USAGE_TRACKING_ENABLED"] = "false"
 os.environ["API_KEY_ENFORCE_ROTATION"] = "false"
 
 ASYNC_DATABASE_URL = "sqlite+aiosqlite:///./test_icc_rules.db"
 
 from app.main import app
 from app.db import get_db, get_async_db, Base
 from app.middleware.dashboard_metrics import DashboardMetricsMiddleware
-from app.middleware.api_key_security import ApiKeySecurityMiddleware
-from app.middleware.tenant import TenantMiddleware
-from app.models.rules import Rule
+from app.models.api_keys import ApiKey
+from app.models.tenants import Tenant
+from app.utils.api_key_utils import generate_api_key
 
 
 @pytest.fixture(scope="session")
 def test_engine() -> Generator:
     """Create test database engine"""
     engine = create_engine(
         "sqlite:///./test_icc_rules.db",
         echo=False,
         connect_args={"check_same_thread": False},
     )
     Base.metadata.create_all(bind=engine)
     yield engine
     Base.metadata.drop_all(bind=engine)
     engine.dispose()
 
 
 @pytest.fixture(scope="session")
 def async_engine(test_engine):
     """Async engine sharing the same SQLite database"""
     engine = create_async_engine(ASYNC_DATABASE_URL, echo=False)
     yield engine
     asyncio.run(engine.dispose())
 
 
 @pytest.fixture(scope="function")
 def test_session(test_engine):
     """Create test database session"""
     TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=test_engine)
     session = TestingSessionLocal()
 
     yield session
 
     session.close()
     with test_engine.begin() as conn:
         for table in reversed(Base.metadata.sorted_tables):
             conn.execute(table.delete())
 
 
 @pytest_asyncio.fixture(scope="function")
 async def db_session(async_engine):
     """Async session fixture for async database usage"""
     session_factory = async_sessionmaker(async_engine, expire_on_commit=False)
     async with session_factory() as session:
         try:
             yield session
         finally:
             await session.rollback()
     async with async_engine.begin() as conn:
         for table in reversed(Base.metadata.sorted_tables):
             await conn.execute(table.delete())
 
 
 @pytest.fixture(scope="function")
 def client(test_session, async_engine):
     """Create test client with overridden dependencies"""
     def override_get_db():
         try:
             yield test_session
         finally:
             pass
 
     async_session_factory = async_sessionmaker(async_engine, expire_on_commit=False)
 
     async def override_get_async_db():
         async with async_session_factory() as session:
             try:
                 yield session
             finally:
                 await session.rollback()
 
     app.dependency_overrides[get_db] = override_get_db
     app.dependency_overrides[get_async_db] = override_get_async_db
 
     original_logging_dispatch = DashboardMetricsMiddleware.dispatch
-    original_security_dispatch = ApiKeySecurityMiddleware.dispatch
-    original_tenant_dispatch = TenantMiddleware.dispatch
 
     async def _noop_dispatch(self, request, call_next):
         return await call_next(request)
 
-    async def _noop_security(self, request, call_next):
-        return await call_next(request)
-
-    async def _noop_tenant(self, request, call_next):
-        return await call_next(request)
-
     DashboardMetricsMiddleware.dispatch = _noop_dispatch
-    ApiKeySecurityMiddleware.dispatch = _noop_security
-    TenantMiddleware.dispatch = _noop_tenant
 
     try:
         yield TestClient(app)
     finally:
         DashboardMetricsMiddleware.dispatch = original_logging_dispatch
-        ApiKeySecurityMiddleware.dispatch = original_security_dispatch
-        TenantMiddleware.dispatch = original_tenant_dispatch
         app.dependency_overrides.clear()
 
 
+
+@pytest.fixture
+def admin_headers(test_session):
+    tenant = test_session.query(Tenant).filter_by(id="admin").first()
+    if tenant is None:
+        tenant = Tenant(
+            id="admin",
+            name="Admin Tenant",
+            plan="Bank",
+            environment="sandbox",
+            active=True,
+        )
+        test_session.add(tenant)
+
+    full_key, prefix, key_hash = generate_api_key()
+    api_key = ApiKey(
+        name=f"admin-test-{uuid4().hex[:6]}",
+        prefix=prefix,
+        key_hash=key_hash,
+        tenant_id=tenant.id,
+        active=True,
+        ip_whitelist=[],
+    )
+    test_session.add(api_key)
+    test_session.commit()
+    return {"X-API-Key": full_key}
+
 @pytest.fixture
 def sample_rule():
     """Sample rule for testing"""
     return {
         "source": "UCP600",
-        "rule_id": "TEST_RULE_001",
+        "rule_id": f"TEST_RULE_{uuid4().hex[:8]}",
         "article": "14",
         "title": "Test Rule",
         "text": "This is a test rule for validation.",
         "condition": {
             "type": "equality_match",
             "left_path": "document_type",
             "right_value": "letter_of_credit",
         },
         "expected_outcome": {
             "action": "validate",
             "result": "compliant",
         },
         "tags": ["test"],
         "severity": "medium",
         "deterministic": True,
         "requires_llm": False,
     }
 
 
 @pytest.fixture
 def sample_llm_rule():
     """Sample LLM rule for testing"""
     return {
         "source": "UCP600",
-        "rule_id": "TEST_LLM_RULE_001",
+        "rule_id": f"TEST_LLM_RULE_{uuid4().hex[:8]}",
         "article": "17",
         "title": "Test LLM Rule",
         "text": "Documents must be consistent on their face.",
         "condition": None,
         "expected_outcome": {
             "action": "check_consistency",
             "result": "consistent",
         },
         "tags": ["test", "llm"],
         "severity": "medium",
         "deterministic": False,
         "requires_llm": True,
     }
 
 
 @pytest.fixture
 def sample_document():
     """Sample document for validation testing"""
     return {
         "id": "TEST_DOC_001",
         "document_type": "letter_of_credit",
         "credit_amount": 100000,
         "presentation_date": "2024-01-15",
         "expiry_date": "2024-02-15",
         "documents": {
             "commercial_invoice": True,
             "bill_of_lading": True,
         },
     }
 
 
 @pytest.fixture
 def sample_ruleset():
     """Sample ruleset for validation testing"""
     return {
         "source": "UCP600",
         "article": "14",
     }
 
 
 @pytest.fixture
 def mock_redis():
     """Mock Redis client for testing"""
     class MockRedis:
         def __init__(self):
             self.data = {}
 
         def get(self, key):
             return self.data.get(key)
 
         def setex(self, key, ttl, value):
             self.data[key] = value
             return True
 
         def info(self):
             return {}
 
         def delete(self, *keys):
             for key in keys:
                 self.data.pop(key, None)
 
         def keys(self, pattern):
             if pattern.endswith("*"):
                 prefix = pattern[:-1]
                 return [k for k in self.data.keys() if k.startswith(prefix)]
             return list(self.data.keys())
 
         def ping(self):
             return True
 
     return MockRedis()