Samir Boulahtit
4cb4fec8e2
- Fix middleware fixtures: vendor_code instead of code, add owner_user_id to company
- Fix performance tests: MarketplaceProduct uses translations for title/description
- Fix security tests: use correct API endpoints (/api/v1/admin/*, /api/v1/vendor/*)
- Fix workflow tests: use actual admin API endpoints
- Fix background task tests: remove invalid vendor_name field, add language
Note: Many middleware integration tests still fail due to dynamic routes
being caught by the /{slug} catch-all route. These tests need further
refactoring to use /api/* prefixed routes.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
473 lines
18 KiB
Python
473 lines
18 KiB
Python
# tests/integration/middleware/test_vendor_context_flow.py
|
|
"""
|
|
Integration tests for vendor context detection end-to-end flow.
|
|
|
|
These tests verify that vendor detection works correctly through real HTTP requests
|
|
for all routing modes: subdomain, custom domain, and path-based.
|
|
"""
|
|
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.mark.integration
|
|
@pytest.mark.middleware
|
|
@pytest.mark.vendor
|
|
class TestVendorContextFlow:
|
|
"""Test vendor context detection through real HTTP requests."""
|
|
|
|
# ========================================================================
|
|
# Subdomain Detection Tests
|
|
# ========================================================================
|
|
|
|
def test_subdomain_vendor_detection(self, client, vendor_with_subdomain):
|
|
"""Test vendor detection via subdomain routing."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-subdomain-detection")
|
|
async def test_subdomain(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_id": (
|
|
request.state.vendor_id
|
|
if hasattr(request.state, "vendor_id")
|
|
else None
|
|
),
|
|
"vendor_code": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
"vendor_name": (
|
|
request.state.vendor.name
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
"detection_method": "subdomain",
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-subdomain-detection",
|
|
headers={"host": f"{vendor_with_subdomain.subdomain}.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is True
|
|
assert data["vendor_id"] == vendor_with_subdomain.id
|
|
assert data["vendor_code"] == vendor_with_subdomain.vendor_code
|
|
assert data["vendor_name"] == vendor_with_subdomain.name
|
|
|
|
def test_subdomain_with_port_detection(self, client, vendor_with_subdomain):
|
|
"""Test vendor detection via subdomain with port number."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-subdomain-port")
|
|
async def test_subdomain_port(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_code": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-subdomain-port",
|
|
headers={
|
|
"host": f"{vendor_with_subdomain.subdomain}.platform.com:8000"
|
|
},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is True
|
|
assert data["vendor_code"] == vendor_with_subdomain.vendor_code
|
|
|
|
def test_nonexistent_subdomain_returns_no_vendor(self, client):
|
|
"""Test that nonexistent subdomain doesn't crash and returns no vendor."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-nonexistent-subdomain")
|
|
async def test_nonexistent(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor": (
|
|
request.state.vendor if hasattr(request.state, "vendor") else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-nonexistent-subdomain",
|
|
headers={"host": "nonexistent.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is False
|
|
|
|
# ========================================================================
|
|
# Custom Domain Detection Tests
|
|
# ========================================================================
|
|
|
|
def test_custom_domain_vendor_detection(self, client, vendor_with_custom_domain):
|
|
"""Test vendor detection via custom domain."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-custom-domain")
|
|
async def test_custom_domain(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_id": (
|
|
request.state.vendor_id
|
|
if hasattr(request.state, "vendor_id")
|
|
else None
|
|
),
|
|
"vendor_code": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
"detection_method": "custom_domain",
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-custom-domain", headers={"host": "customdomain.com"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is True
|
|
assert data["vendor_id"] == vendor_with_custom_domain.id
|
|
assert data["vendor_code"] == vendor_with_custom_domain.vendor_code
|
|
|
|
def test_custom_domain_with_www_detection(self, client, vendor_with_custom_domain):
|
|
"""Test vendor detection via custom domain with www prefix."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-custom-domain-www")
|
|
async def test_custom_domain_www(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_code": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
# Test with www prefix - should still detect vendor
|
|
response = client.get(
|
|
"/test-custom-domain-www", headers={"host": "www.customdomain.com"}
|
|
)
|
|
|
|
# This might fail if your implementation doesn't strip www
|
|
# Adjust assertion based on your actual behavior
|
|
assert response.status_code == 200
|
|
|
|
# ========================================================================
|
|
# Path-Based Detection Tests (Development Mode)
|
|
# ========================================================================
|
|
|
|
def test_path_based_vendor_detection_vendors_prefix(
|
|
self, client, vendor_with_subdomain
|
|
):
|
|
"""Test vendor detection via path-based routing with /vendors/ prefix."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/vendors/{vendor_code}/test-path")
|
|
async def test_path_based(vendor_code: str, request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_code_param": vendor_code,
|
|
"vendor_code_state": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
"clean_path": (
|
|
request.state.clean_path
|
|
if hasattr(request.state, "clean_path")
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
f"/vendors/{vendor_with_subdomain.vendor_code}/test-path",
|
|
headers={"host": "localhost:8000"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is True
|
|
assert data["vendor_code_param"] == vendor_with_subdomain.vendor_code
|
|
assert data["vendor_code_state"] == vendor_with_subdomain.vendor_code
|
|
|
|
def test_path_based_vendor_detection_vendor_prefix(
|
|
self, client, vendor_with_subdomain
|
|
):
|
|
"""Test vendor detection via path-based routing with /vendor/ prefix."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/vendor/{vendor_code}/test")
|
|
async def test_vendor_path(vendor_code: str, request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None,
|
|
"vendor_code": (
|
|
request.state.vendor.vendor_code
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
f"/vendor/{vendor_with_subdomain.vendor_code}/test",
|
|
headers={"host": "localhost:8000"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is True
|
|
assert data["vendor_code"] == vendor_with_subdomain.vendor_code
|
|
|
|
# ========================================================================
|
|
# Clean Path Extraction Tests
|
|
# ========================================================================
|
|
|
|
def test_clean_path_extracted_from_vendor_prefix(
|
|
self, client, vendor_with_subdomain
|
|
):
|
|
"""Test that clean_path is correctly extracted from path-based routing."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/vendors/{vendor_code}/shop/products")
|
|
async def test_clean_path(vendor_code: str, request: Request):
|
|
return {
|
|
"clean_path": (
|
|
request.state.clean_path
|
|
if hasattr(request.state, "clean_path")
|
|
else None
|
|
),
|
|
"original_path": request.url.path,
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
f"/vendors/{vendor_with_subdomain.vendor_code}/shop/products",
|
|
headers={"host": "localhost:8000"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
# Clean path should have vendor prefix removed
|
|
assert data["clean_path"] == "/shop/products"
|
|
assert (
|
|
f"/vendors/{vendor_with_subdomain.vendor_code}/shop/products"
|
|
in data["original_path"]
|
|
)
|
|
|
|
def test_clean_path_unchanged_for_subdomain(self, client, vendor_with_subdomain):
|
|
"""Test that clean_path equals original path for subdomain routing."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/shop/test-clean-path")
|
|
async def test_subdomain_clean_path(request: Request):
|
|
return {
|
|
"clean_path": (
|
|
request.state.clean_path
|
|
if hasattr(request.state, "clean_path")
|
|
else None
|
|
),
|
|
"original_path": request.url.path,
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/shop/test-clean-path",
|
|
headers={"host": f"{vendor_with_subdomain.subdomain}.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
# For subdomain routing, clean path should equal original path
|
|
assert data["clean_path"] == data["original_path"]
|
|
assert data["clean_path"] == "/shop/test-clean-path"
|
|
|
|
# ========================================================================
|
|
# Vendor State Injection Tests
|
|
# ========================================================================
|
|
|
|
def test_vendor_id_injected_into_request_state(self, client, vendor_with_subdomain):
|
|
"""Test that vendor_id is correctly injected into request.state."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-vendor-id-injection")
|
|
async def test_vendor_id(request: Request):
|
|
return {
|
|
"has_vendor_id": hasattr(request.state, "vendor_id"),
|
|
"vendor_id": (
|
|
request.state.vendor_id
|
|
if hasattr(request.state, "vendor_id")
|
|
else None
|
|
),
|
|
"vendor_id_type": (
|
|
type(request.state.vendor_id).__name__
|
|
if hasattr(request.state, "vendor_id")
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-vendor-id-injection",
|
|
headers={"host": f"{vendor_with_subdomain.subdomain}.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["has_vendor_id"] is True
|
|
assert data["vendor_id"] == vendor_with_subdomain.id
|
|
assert data["vendor_id_type"] == "int"
|
|
|
|
def test_vendor_object_injected_into_request_state(
|
|
self, client, vendor_with_subdomain
|
|
):
|
|
"""Test that full vendor object is injected into request.state."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-vendor-object-injection")
|
|
async def test_vendor_object(request: Request):
|
|
vendor = (
|
|
request.state.vendor
|
|
if hasattr(request.state, "vendor") and request.state.vendor
|
|
else None
|
|
)
|
|
return {
|
|
"has_vendor": vendor is not None,
|
|
"vendor_attributes": (
|
|
{
|
|
"id": vendor.id if vendor else None,
|
|
"name": vendor.name if vendor else None,
|
|
"code": vendor.vendor_code if vendor else None,
|
|
"subdomain": vendor.subdomain if vendor else None,
|
|
"is_active": vendor.is_active if vendor else None,
|
|
}
|
|
if vendor
|
|
else None
|
|
),
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-vendor-object-injection",
|
|
headers={"host": f"{vendor_with_subdomain.subdomain}.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["has_vendor"] is True
|
|
assert data["vendor_attributes"]["id"] == vendor_with_subdomain.id
|
|
assert data["vendor_attributes"]["name"] == vendor_with_subdomain.name
|
|
assert data["vendor_attributes"]["code"] == vendor_with_subdomain.vendor_code
|
|
assert data["vendor_attributes"]["is_active"] is True
|
|
|
|
# ========================================================================
|
|
# Edge Cases and Error Handling
|
|
# ========================================================================
|
|
|
|
def test_inactive_vendor_not_detected(self, client, middleware_inactive_vendor):
|
|
"""Test that inactive vendors are not detected."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-inactive-vendor-detection")
|
|
async def test_inactive(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-inactive-vendor-detection",
|
|
headers={"host": f"{middleware_inactive_vendor.subdomain}.platform.com"},
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is False
|
|
|
|
def test_platform_domain_without_subdomain_no_vendor(self, client):
|
|
"""Test that platform domain without subdomain doesn't detect vendor."""
|
|
from fastapi import Request
|
|
|
|
from main import app
|
|
|
|
@app.get("/test-platform-domain")
|
|
async def test_platform(request: Request):
|
|
return {
|
|
"vendor_detected": hasattr(request.state, "vendor")
|
|
and request.state.vendor is not None
|
|
}
|
|
|
|
with patch("app.core.config.settings") as mock_settings:
|
|
mock_settings.platform_domain = "platform.com"
|
|
response = client.get(
|
|
"/test-platform-domain", headers={"host": "platform.com"}
|
|
)
|
|
|
|
assert response.status_code == 200
|
|
data = response.json()
|
|
assert data["vendor_detected"] is False
|