test(admin): add foreign key fixtures and CRUD/filter regressions

Author: ayahaustine

tests/conftest.py

@@ -8,9 +8,9 @@
 import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
-from sqlalchemy import create_engine, Column, Integer, String, Boolean
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, ForeignKey
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.orm import sessionmaker, Session, relationship
 
 from internal_admin import AdminSite, AdminConfig, ModelAdmin
 from internal_admin.auth.models import AdminUser
@@ -30,6 +30,10 @@ class TestUser(Base):
     is_active = Column(Boolean, default=True)
     is_superuser = Column(Boolean, default=False)
 
+    @property
+    def display_name(self) -> str:
+        return self.username or f"User {self.id}"
+
 
 class TestModel(Base):
     """Simple test model for admin testing."""
@@ -41,13 +45,51 @@ class TestModel(Base):
     is_active = Column(Boolean, default=True)
 
 
+class TestCategory(Base):
+    """Related model for foreign key tests."""
+    __tablename__ = "test_categories"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(100), nullable=False)
+
+    products = relationship("TestProduct", back_populates="category")
+
+    def __str__(self) -> str:
+        return self.name
+
+
+class TestProduct(Base):
+    """Model containing a foreign key for admin tests."""
+    __tablename__ = "test_products"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(100), nullable=False)
+    category_id = Column(Integer, ForeignKey("test_categories.id"), nullable=False)
+    is_active = Column(Boolean, default=True)
+
+    category = relationship("TestCategory", back_populates="products")
+
+
 class TestModelAdmin(ModelAdmin):
     """Test ModelAdmin configuration."""
     list_display = ["id", "name", "is_active"]
     search_fields = ["name", "description"]
     list_filter = ["is_active"]
 
 
+class TestCategoryAdmin(ModelAdmin):
+    """Admin configuration for category model."""
+    list_display = ["id", "name"]
+    search_fields = ["name"]
+
+
+class TestProductAdmin(ModelAdmin):
+    """Admin configuration for product model."""
+    list_display = ["id", "name", "category_id", "is_active"]
+    search_fields = ["name"]
+    list_filter = ["category_id", "is_active"]
+
+
 @pytest.fixture(scope="session")
 def test_db() -> Generator[str, None, None]:
     """Create a temporary test database."""
@@ -87,6 +129,8 @@ def admin_site(admin_config: AdminConfig) -> AdminSite:
     # Create fresh AdminSite after clearing registry
     site = AdminSite(admin_config)
     site.register(TestModel, TestModelAdmin)
+    site.register(TestCategory, TestCategoryAdmin)
+    site.register(TestProduct, TestProductAdmin)
     return site
 
 
@@ -150,6 +194,29 @@ def test_objects(db_session: Session) -> list[TestModel]:
     return objects
 
 
+@pytest.fixture
+def fk_objects(db_session: Session) -> dict[str, Any]:
+    """Create related objects for foreign key tests."""
+    categories = [
+        TestCategory(name="Hardware"),
+        TestCategory(name="Software"),
+    ]
+    db_session.add_all(categories)
+    db_session.flush()
+
+    products = [
+        TestProduct(name="Keyboard", category_id=categories[0].id, is_active=True),
+        TestProduct(name="IDE License", category_id=categories[1].id, is_active=True),
+    ]
+    db_session.add_all(products)
+    db_session.commit()
+
+    return {
+        "categories": categories,
+        "products": products,
+    }
+
+
 @pytest.fixture
 def authenticated_client(client: TestClient, test_user: TestUser) -> TestClient:
     """Create authenticated test client."""

tests/test_admin.py

@@ -10,35 +10,33 @@
 
 class TestAdminSite:
     """Test AdminSite functionality."""
-    
+
     def test_admin_site_creation(self, admin_config: AdminConfig):
         """Test AdminSite can be created."""
         site = AdminSite(admin_config)
         assert site.config == admin_config
         assert not site._initialized
-    
+
     def test_model_registration(self, admin_site: AdminSite):
         """Test model registration works."""
         from tests.conftest import TestModel, TestUser
         assert admin_site.is_registered(TestModel)
         assert not admin_site.is_registered(TestUser)
-    
+
     def test_get_registered_models(self, admin_site: AdminSite):
         """Test getting registered models."""
         models = admin_site.get_registered_models()
         assert len(models) == 1
-        # Check that TestModel is registered (by class name since import paths may differ)
         model_names = [model.__name__ for model in models.keys()]
         assert "TestModel" in model_names
 
 
 class TestAdminConfig:
     """Test AdminConfig functionality."""
-    
+
     def test_config_validation(self, test_db: str):
         """Test config validation."""
         from tests.conftest import TestUser
-        # Valid config should work
         config = AdminConfig(
             database_url=test_db,
             secret_key="test-key",
@@ -47,7 +45,7 @@ def test_config_validation(self, test_db: str):
         assert config.database_url == test_db
         assert config.is_sqlite
         assert not config.is_postgresql
-    
+
     def test_invalid_config(self):
         """Test invalid config raises errors."""
         from tests.conftest import TestUser
@@ -57,7 +55,7 @@ def test_invalid_config(self):
                 secret_key="test-key",
                 user_model=TestUser
             )
-        
+
         with pytest.raises(ValueError, match="secret_key is required"):
             AdminConfig(
                 database_url="sqlite:///test.db",
@@ -68,47 +66,46 @@ def test_invalid_config(self):
 
 class TestModelAdmin:
     """Test ModelAdmin functionality."""
-    
+
     def test_model_admin_creation(self):
         """Test ModelAdmin can be created."""
         from tests.conftest import TestModel
         admin = ModelAdmin(TestModel)
         assert admin.model == TestModel
-    
+
     def test_list_display(self):
         """Test list_display configuration."""
         from tests.conftest import TestModel
         admin = ModelAdmin(TestModel)
-        
-        # Should return default columns if not configured
+
         display_fields = admin.get_list_display()
         assert "id" in display_fields
         assert "name" in display_fields
-    
+
     def test_search_fields(self):
         """Test search_fields configuration."""
         from tests.conftest import TestModel
         admin = ModelAdmin(TestModel)
         admin.search_fields = ["name"]
-        
+
         search_fields = admin.get_search_fields()
         assert search_fields == ["name"]
 
 
 class TestAdminRoutes:
     """Test admin route functionality."""
-    
+
     def test_dashboard_requires_auth(self, client: TestClient):
         """Test dashboard requires authentication."""
         response = client.get("/admin/")
         assert response.status_code == 401
-    
+
     def test_login_page(self, client: TestClient):
         """Test login page is accessible."""
         response = client.get("/admin/login")
         assert response.status_code == 200
         assert "login" in response.text.lower()
-    
+
     def test_model_list_requires_auth(self, client: TestClient):
         """Test model list requires authentication."""
         response = client.get("/admin/testmodel/")
@@ -117,24 +114,24 @@ def test_model_list_requires_auth(self, client: TestClient):
 
 class TestAuthentication:
     """Test authentication functionality."""
-    
+
     def test_successful_login(self, client: TestClient, test_user):
         """Test successful login."""
         response = client.post("/admin/login", data={
             "username": test_user.username,
             "password": "testpass123"
         })
-        assert response.status_code == 302  # Redirect after login
-    
+        assert response.status_code == 302
+
     def test_invalid_login(self, client: TestClient):
         """Test invalid login credentials."""
         response = client.post("/admin/login", data={
             "username": "nonexistent",
             "password": "wrongpass"
         })
-        assert response.status_code == 302  # Redirect to login with error
+        assert response.status_code == 302
         assert "error=invalid_credentials" in response.headers["location"]
-    
+
     def test_authenticated_dashboard_access(self, authenticated_client: TestClient):
         """Test authenticated users can access dashboard."""
         response = authenticated_client.get("/admin/")
@@ -144,36 +141,36 @@ def test_authenticated_dashboard_access(self, authenticated_client: TestClient):
 
 class TestCRUDOperations:
     """Test CRUD operations via admin interface."""
-    
+
     def test_model_list_view(self, authenticated_client: TestClient, test_objects):
         """Test model list view."""
         response = authenticated_client.get("/admin/testmodel/")
         assert response.status_code == 200
         assert "Test 1" in response.text
         assert "Test 2" in response.text
-    
+
     def test_create_form_view(self, authenticated_client: TestClient):
         """Test create form view."""
         response = authenticated_client.get("/admin/testmodel/create/")
         assert response.status_code == 200
         assert "form" in response.text.lower()
         assert "name" in response.text.lower()
-    
+
     def test_create_object(self, authenticated_client: TestClient):
         """Test creating new object."""
         response = authenticated_client.post("/admin/testmodel/create/", data={
             "name": "New Test Object",
             "description": "Created via test",
             "is_active": True
         })
-        assert response.status_code == 302  # Redirect after create
-    
+        assert response.status_code == 302
+
     def test_edit_form_view(self, authenticated_client: TestClient, test_objects):
         """Test edit form view."""
         response = authenticated_client.get(f"/admin/testmodel/{test_objects[0].id}/")
         assert response.status_code == 200
         assert test_objects[0].name in response.text
-    
+
     def test_delete_confirmation(self, authenticated_client: TestClient, test_objects):
         """Test delete confirmation page."""
         response = authenticated_client.get(f"/admin/testmodel/{test_objects[0].id}/delete/")
@@ -184,29 +181,64 @@ def test_delete_confirmation(self, authenticated_client: TestClient, test_object
 
 class TestSearchAndFiltering:
     """Test search and filtering functionality."""
-    
+
     def test_search(self, authenticated_client: TestClient, test_objects):
         """Test search functionality."""
         response = authenticated_client.get("/admin/testmodel/?search=Test 1")
         assert response.status_code == 200
         assert "Test 1" in response.text
-    
+
     def test_filter(self, authenticated_client: TestClient, test_objects):
         """Test filtering functionality."""
         response = authenticated_client.get("/admin/testmodel/?is_active=true")
         assert response.status_code == 200
-        # Should show active objects but not inactive ones
 
 
 class TestPermissions:
     """Test permission system."""
-    
+
     def test_superuser_permissions(self, authenticated_client: TestClient):
         """Test superuser has all permissions."""
-        # Should be able to access model list
         response = authenticated_client.get("/admin/testmodel/")
         assert response.status_code == 200
-        
-        # Should be able to access create form
+
         response = authenticated_client.get("/admin/testmodel/create/")
-        assert response.status_code == 200
+        assert response.status_code == 200
+
+
+class TestForeignKeys:
+    """Test foreign key functionality in forms and filters."""
+
+    def test_fk_field_renders_select_choices(self, authenticated_client: TestClient, fk_objects):
+        """Create form should render related model choices for FK fields."""
+        response = authenticated_client.get("/admin/testproduct/create/")
+        assert response.status_code == 200
+        assert "category_id" in response.text
+        assert "Hardware" in response.text
+        assert "Software" in response.text
+
+    def test_fk_create_submission_persists_relation(self, authenticated_client: TestClient, db_session, fk_objects):
+        """Submitting FK value should be validated and persisted correctly."""
+        from tests.conftest import TestProduct
+
+        hardware_id = fk_objects["categories"][0].id
+        response = authenticated_client.post("/admin/testproduct/create/", data={
+            "name": "Mouse",
+            "category_id": str(hardware_id),
+            "is_active": "true",
+        })
+
+        assert response.status_code == 302
+
+        created = db_session.query(TestProduct).filter(TestProduct.name == "Mouse").first()
+        assert created is not None
+        assert created.category_id == hardware_id
+
+    def test_fk_filter_applies_correctly(self, authenticated_client: TestClient, fk_objects):
+        """FK list filter should match rows by related ID."""
+        software_id = fk_objects["categories"][1].id
+        response = authenticated_client.get(f"/admin/testproduct/?category_id={software_id}")
+
+        assert response.status_code == 200
+        assert "IDE License" in response.text
+        assert "Keyboard" not in response.text