refactor: split database model tests into organized modules
Split the monolithic test_database_models.py into focused test modules: Database model tests (tests/unit/models/database/): - test_customer.py: Customer model and authentication tests - test_inventory.py: Inventory model tests - test_marketplace_import_job.py: Import job model tests - test_marketplace_product.py: Marketplace product model tests - test_order.py: Order and OrderItem model tests - test_product.py: Product model tests - test_team.py: Team invitation and membership tests - test_user.py: User model tests - test_vendor.py: Vendor model tests Schema validation tests (tests/unit/models/schema/): - test_auth.py: Auth schema validation tests - test_customer.py: Customer schema validation tests - test_inventory.py: Inventory schema validation tests - test_marketplace_import_job.py: Import job schema tests - test_order.py: Order schema validation tests - test_product.py: Product schema validation tests This improves test organization and makes it easier to find and maintain tests for specific models. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
2
tests/unit/models/schema/__init__.py
Normal file
2
tests/unit/models/schema/__init__.py
Normal file
@@ -0,0 +1,2 @@
|
||||
# tests/unit/models/schema/__init__.py
|
||||
"""Pydantic schema unit tests."""
|
||||
275
tests/unit/models/schema/test_auth.py
Normal file
275
tests/unit/models/schema/test_auth.py
Normal file
@@ -0,0 +1,275 @@
|
||||
# tests/unit/models/schema/test_auth.py
|
||||
"""Unit tests for auth Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.auth import (
|
||||
UserCreate,
|
||||
UserLogin,
|
||||
UserRegister,
|
||||
UserResponse,
|
||||
UserUpdate,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestUserRegisterSchema:
|
||||
"""Test UserRegister schema validation."""
|
||||
|
||||
def test_valid_registration(self):
|
||||
"""Test valid registration data."""
|
||||
user = UserRegister(
|
||||
email="test@example.com",
|
||||
username="testuser",
|
||||
password="password123",
|
||||
)
|
||||
assert user.email == "test@example.com"
|
||||
assert user.username == "testuser"
|
||||
assert user.password == "password123"
|
||||
|
||||
def test_username_normalized_to_lowercase(self):
|
||||
"""Test username is normalized to lowercase."""
|
||||
user = UserRegister(
|
||||
email="test@example.com",
|
||||
username="TestUser",
|
||||
password="password123",
|
||||
)
|
||||
assert user.username == "testuser"
|
||||
|
||||
def test_username_with_whitespace_invalid(self):
|
||||
"""Test username with whitespace is invalid (validation before strip)."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserRegister(
|
||||
email="test@example.com",
|
||||
username=" testuser ",
|
||||
password="password123",
|
||||
)
|
||||
assert "username" in str(exc_info.value).lower()
|
||||
|
||||
def test_invalid_email(self):
|
||||
"""Test invalid email raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserRegister(
|
||||
email="not-an-email",
|
||||
username="testuser",
|
||||
password="password123",
|
||||
)
|
||||
assert "email" in str(exc_info.value).lower()
|
||||
|
||||
def test_invalid_username_special_chars(self):
|
||||
"""Test username with special characters raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserRegister(
|
||||
email="test@example.com",
|
||||
username="test@user!",
|
||||
password="password123",
|
||||
)
|
||||
assert "username" in str(exc_info.value).lower()
|
||||
|
||||
def test_valid_username_with_underscore(self):
|
||||
"""Test username with underscore is valid."""
|
||||
user = UserRegister(
|
||||
email="test@example.com",
|
||||
username="test_user_123",
|
||||
password="password123",
|
||||
)
|
||||
assert user.username == "test_user_123"
|
||||
|
||||
def test_password_too_short(self):
|
||||
"""Test password shorter than 6 characters raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserRegister(
|
||||
email="test@example.com",
|
||||
username="testuser",
|
||||
password="12345",
|
||||
)
|
||||
assert "password" in str(exc_info.value).lower()
|
||||
|
||||
def test_password_exactly_6_chars(self):
|
||||
"""Test password with exactly 6 characters is valid."""
|
||||
user = UserRegister(
|
||||
email="test@example.com",
|
||||
username="testuser",
|
||||
password="123456",
|
||||
)
|
||||
assert user.password == "123456"
|
||||
|
||||
def test_missing_required_fields(self):
|
||||
"""Test missing required fields raises ValidationError."""
|
||||
with pytest.raises(ValidationError):
|
||||
UserRegister(email="test@example.com")
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestUserLoginSchema:
|
||||
"""Test UserLogin schema validation."""
|
||||
|
||||
def test_valid_login(self):
|
||||
"""Test valid login data."""
|
||||
login = UserLogin(
|
||||
email_or_username="testuser",
|
||||
password="password123",
|
||||
)
|
||||
assert login.email_or_username == "testuser"
|
||||
assert login.password == "password123"
|
||||
|
||||
def test_login_with_email(self):
|
||||
"""Test login with email."""
|
||||
login = UserLogin(
|
||||
email_or_username="test@example.com",
|
||||
password="password123",
|
||||
)
|
||||
assert login.email_or_username == "test@example.com"
|
||||
|
||||
def test_login_with_vendor_code(self):
|
||||
"""Test login with optional vendor code."""
|
||||
login = UserLogin(
|
||||
email_or_username="testuser",
|
||||
password="password123",
|
||||
vendor_code="VENDOR001",
|
||||
)
|
||||
assert login.vendor_code == "VENDOR001"
|
||||
|
||||
def test_email_or_username_stripped(self):
|
||||
"""Test email_or_username is stripped of whitespace."""
|
||||
login = UserLogin(
|
||||
email_or_username=" testuser ",
|
||||
password="password123",
|
||||
)
|
||||
assert login.email_or_username == "testuser"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestUserCreateSchema:
|
||||
"""Test UserCreate schema validation."""
|
||||
|
||||
def test_valid_user_create(self):
|
||||
"""Test valid user creation data."""
|
||||
user = UserCreate(
|
||||
email="admin@example.com",
|
||||
username="adminuser",
|
||||
password="securepass",
|
||||
first_name="Admin",
|
||||
last_name="User",
|
||||
role="admin",
|
||||
)
|
||||
assert user.email == "admin@example.com"
|
||||
assert user.role == "admin"
|
||||
|
||||
def test_default_role_is_vendor(self):
|
||||
"""Test default role is vendor."""
|
||||
user = UserCreate(
|
||||
email="vendor@example.com",
|
||||
username="vendoruser",
|
||||
password="securepass",
|
||||
)
|
||||
assert user.role == "vendor"
|
||||
|
||||
def test_invalid_role(self):
|
||||
"""Test invalid role raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserCreate(
|
||||
email="test@example.com",
|
||||
username="testuser",
|
||||
password="securepass",
|
||||
role="superadmin",
|
||||
)
|
||||
assert "role" in str(exc_info.value).lower()
|
||||
|
||||
def test_username_too_short(self):
|
||||
"""Test username shorter than 3 characters raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserCreate(
|
||||
email="test@example.com",
|
||||
username="ab",
|
||||
password="securepass",
|
||||
)
|
||||
assert "username" in str(exc_info.value).lower()
|
||||
|
||||
def test_password_min_length(self):
|
||||
"""Test password minimum length validation."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
UserCreate(
|
||||
email="test@example.com",
|
||||
username="testuser",
|
||||
password="12345",
|
||||
)
|
||||
assert "password" in str(exc_info.value).lower()
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestUserUpdateSchema:
|
||||
"""Test UserUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = UserUpdate(first_name="NewName")
|
||||
assert update.first_name == "NewName"
|
||||
assert update.username is None
|
||||
assert update.email is None
|
||||
|
||||
def test_username_update_normalized(self):
|
||||
"""Test username in update is normalized."""
|
||||
update = UserUpdate(username="NewUser")
|
||||
assert update.username == "newuser"
|
||||
|
||||
def test_invalid_role_update(self):
|
||||
"""Test invalid role in update raises ValidationError."""
|
||||
with pytest.raises(ValidationError):
|
||||
UserUpdate(role="superadmin")
|
||||
|
||||
def test_valid_role_update(self):
|
||||
"""Test valid role values."""
|
||||
admin_update = UserUpdate(role="admin")
|
||||
vendor_update = UserUpdate(role="vendor")
|
||||
assert admin_update.role == "admin"
|
||||
assert vendor_update.role == "vendor"
|
||||
|
||||
def test_empty_update(self):
|
||||
"""Test empty update is valid (all fields optional)."""
|
||||
update = UserUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestUserResponseSchema:
|
||||
"""Test UserResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"email": "test@example.com",
|
||||
"username": "testuser",
|
||||
"role": "vendor",
|
||||
"is_active": True,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = UserResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.email == "test@example.com"
|
||||
assert response.is_active is True
|
||||
|
||||
def test_optional_last_login(self):
|
||||
"""Test last_login is optional."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"email": "test@example.com",
|
||||
"username": "testuser",
|
||||
"role": "vendor",
|
||||
"is_active": True,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = UserResponse(**data)
|
||||
assert response.last_login is None
|
||||
364
tests/unit/models/schema/test_customer.py
Normal file
364
tests/unit/models/schema/test_customer.py
Normal file
@@ -0,0 +1,364 @@
|
||||
# tests/unit/models/schema/test_customer.py
|
||||
"""Unit tests for customer Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.customer import (
|
||||
CustomerRegister,
|
||||
CustomerUpdate,
|
||||
CustomerResponse,
|
||||
CustomerAddressCreate,
|
||||
CustomerAddressUpdate,
|
||||
CustomerAddressResponse,
|
||||
CustomerPreferencesUpdate,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerRegisterSchema:
|
||||
"""Test CustomerRegister schema validation."""
|
||||
|
||||
def test_valid_registration(self):
|
||||
"""Test valid registration data."""
|
||||
customer = CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Password123",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert customer.email == "customer@example.com"
|
||||
assert customer.first_name == "John"
|
||||
assert customer.last_name == "Doe"
|
||||
|
||||
def test_email_normalized_to_lowercase(self):
|
||||
"""Test email is normalized to lowercase."""
|
||||
customer = CustomerRegister(
|
||||
email="Customer@Example.COM",
|
||||
password="Password123",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert customer.email == "customer@example.com"
|
||||
|
||||
def test_invalid_email(self):
|
||||
"""Test invalid email raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerRegister(
|
||||
email="not-an-email",
|
||||
password="Password123",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert "email" in str(exc_info.value).lower()
|
||||
|
||||
def test_password_min_length(self):
|
||||
"""Test password must be at least 8 characters."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Pass1",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert "password" in str(exc_info.value).lower()
|
||||
|
||||
def test_password_requires_digit(self):
|
||||
"""Test password must contain at least one digit."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Password",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert "digit" in str(exc_info.value).lower()
|
||||
|
||||
def test_password_requires_letter(self):
|
||||
"""Test password must contain at least one letter."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="12345678",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert "letter" in str(exc_info.value).lower()
|
||||
|
||||
def test_first_name_required(self):
|
||||
"""Test first_name is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Password123",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert "first_name" in str(exc_info.value).lower()
|
||||
|
||||
def test_marketing_consent_default(self):
|
||||
"""Test marketing_consent defaults to False."""
|
||||
customer = CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Password123",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
)
|
||||
assert customer.marketing_consent is False
|
||||
|
||||
def test_optional_phone(self):
|
||||
"""Test optional phone field."""
|
||||
customer = CustomerRegister(
|
||||
email="customer@example.com",
|
||||
password="Password123",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
phone="+352 123 456",
|
||||
)
|
||||
assert customer.phone == "+352 123 456"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerUpdateSchema:
|
||||
"""Test CustomerUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = CustomerUpdate(first_name="Jane")
|
||||
assert update.first_name == "Jane"
|
||||
assert update.last_name is None
|
||||
assert update.email is None
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid."""
|
||||
update = CustomerUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
def test_email_normalized_to_lowercase(self):
|
||||
"""Test email is normalized to lowercase."""
|
||||
update = CustomerUpdate(email="NewEmail@Example.COM")
|
||||
assert update.email == "newemail@example.com"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerResponseSchema:
|
||||
"""Test CustomerResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_id": 1,
|
||||
"email": "customer@example.com",
|
||||
"first_name": "John",
|
||||
"last_name": "Doe",
|
||||
"phone": None,
|
||||
"customer_number": "CUST001",
|
||||
"marketing_consent": False,
|
||||
"last_order_date": None,
|
||||
"total_orders": 5,
|
||||
"total_spent": Decimal("500.00"),
|
||||
"is_active": True,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = CustomerResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.customer_number == "CUST001"
|
||||
assert response.total_orders == 5
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerAddressCreateSchema:
|
||||
"""Test CustomerAddressCreate schema validation."""
|
||||
|
||||
def test_valid_shipping_address(self):
|
||||
"""Test valid shipping address creation."""
|
||||
address = CustomerAddressCreate(
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.address_type == "shipping"
|
||||
assert address.city == "Luxembourg"
|
||||
|
||||
def test_valid_billing_address(self):
|
||||
"""Test valid billing address creation."""
|
||||
address = CustomerAddressCreate(
|
||||
address_type="billing",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.address_type == "billing"
|
||||
|
||||
def test_invalid_address_type(self):
|
||||
"""Test invalid address_type raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
CustomerAddressCreate(
|
||||
address_type="delivery",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert "address_type" in str(exc_info.value).lower()
|
||||
|
||||
def test_is_default_defaults_to_false(self):
|
||||
"""Test is_default defaults to False."""
|
||||
address = CustomerAddressCreate(
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.is_default is False
|
||||
|
||||
def test_optional_company(self):
|
||||
"""Test optional company field."""
|
||||
address = CustomerAddressCreate(
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
company="Tech Corp",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.company == "Tech Corp"
|
||||
|
||||
def test_optional_address_line_2(self):
|
||||
"""Test optional address_line_2 field."""
|
||||
address = CustomerAddressCreate(
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
address_line_2="Apt 4B",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.address_line_2 == "Apt 4B"
|
||||
|
||||
def test_required_fields(self):
|
||||
"""Test required fields."""
|
||||
with pytest.raises(ValidationError):
|
||||
CustomerAddressCreate(
|
||||
address_type="shipping",
|
||||
first_name="John",
|
||||
# missing last_name, address_line_1, city, postal_code, country
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerAddressUpdateSchema:
|
||||
"""Test CustomerAddressUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = CustomerAddressUpdate(city="Esch-sur-Alzette")
|
||||
assert update.city == "Esch-sur-Alzette"
|
||||
assert update.first_name is None
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid."""
|
||||
update = CustomerAddressUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
def test_address_type_validation(self):
|
||||
"""Test address_type validation in update."""
|
||||
with pytest.raises(ValidationError):
|
||||
CustomerAddressUpdate(address_type="invalid")
|
||||
|
||||
def test_valid_address_type_update(self):
|
||||
"""Test valid address_type values in update."""
|
||||
shipping = CustomerAddressUpdate(address_type="shipping")
|
||||
billing = CustomerAddressUpdate(address_type="billing")
|
||||
assert shipping.address_type == "shipping"
|
||||
assert billing.address_type == "billing"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerAddressResponseSchema:
|
||||
"""Test CustomerAddressResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_id": 1,
|
||||
"customer_id": 1,
|
||||
"address_type": "shipping",
|
||||
"first_name": "John",
|
||||
"last_name": "Doe",
|
||||
"company": None,
|
||||
"address_line_1": "123 Main St",
|
||||
"address_line_2": None,
|
||||
"city": "Luxembourg",
|
||||
"postal_code": "L-1234",
|
||||
"country": "Luxembourg",
|
||||
"is_default": True,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = CustomerAddressResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.is_default is True
|
||||
assert response.address_type == "shipping"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestCustomerPreferencesUpdateSchema:
|
||||
"""Test CustomerPreferencesUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = CustomerPreferencesUpdate(marketing_consent=True)
|
||||
assert update.marketing_consent is True
|
||||
assert update.language is None
|
||||
|
||||
def test_language_update(self):
|
||||
"""Test language preference update."""
|
||||
update = CustomerPreferencesUpdate(language="fr")
|
||||
assert update.language == "fr"
|
||||
|
||||
def test_currency_update(self):
|
||||
"""Test currency preference update."""
|
||||
update = CustomerPreferencesUpdate(currency="EUR")
|
||||
assert update.currency == "EUR"
|
||||
|
||||
def test_notification_preferences(self):
|
||||
"""Test notification preferences dict."""
|
||||
update = CustomerPreferencesUpdate(
|
||||
notification_preferences={
|
||||
"email": True,
|
||||
"sms": False,
|
||||
"push": True,
|
||||
}
|
||||
)
|
||||
assert update.notification_preferences["email"] is True
|
||||
assert update.notification_preferences["sms"] is False
|
||||
299
tests/unit/models/schema/test_inventory.py
Normal file
299
tests/unit/models/schema/test_inventory.py
Normal file
@@ -0,0 +1,299 @@
|
||||
# tests/unit/models/schema/test_inventory.py
|
||||
"""Unit tests for inventory Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.inventory import (
|
||||
InventoryBase,
|
||||
InventoryCreate,
|
||||
InventoryAdjust,
|
||||
InventoryUpdate,
|
||||
InventoryReserve,
|
||||
InventoryResponse,
|
||||
InventoryLocationResponse,
|
||||
ProductInventorySummary,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryCreateSchema:
|
||||
"""Test InventoryCreate schema validation."""
|
||||
|
||||
def test_valid_inventory_create(self):
|
||||
"""Test valid inventory creation data."""
|
||||
inventory = InventoryCreate(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=100,
|
||||
)
|
||||
assert inventory.product_id == 1
|
||||
assert inventory.location == "Warehouse A"
|
||||
assert inventory.quantity == 100
|
||||
|
||||
def test_product_id_required(self):
|
||||
"""Test product_id is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
InventoryCreate(location="Warehouse A", quantity=10)
|
||||
assert "product_id" in str(exc_info.value).lower()
|
||||
|
||||
def test_location_required(self):
|
||||
"""Test location is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
InventoryCreate(product_id=1, quantity=10)
|
||||
assert "location" in str(exc_info.value).lower()
|
||||
|
||||
def test_quantity_required(self):
|
||||
"""Test quantity is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
InventoryCreate(product_id=1, location="Warehouse A")
|
||||
assert "quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_quantity_must_be_non_negative(self):
|
||||
"""Test quantity must be >= 0."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
InventoryCreate(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=-5,
|
||||
)
|
||||
assert "quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_quantity_zero_is_valid(self):
|
||||
"""Test quantity of 0 is valid."""
|
||||
inventory = InventoryCreate(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=0,
|
||||
)
|
||||
assert inventory.quantity == 0
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryAdjustSchema:
|
||||
"""Test InventoryAdjust schema validation."""
|
||||
|
||||
def test_positive_adjustment(self):
|
||||
"""Test positive quantity adjustment (add stock)."""
|
||||
adjustment = InventoryAdjust(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=50,
|
||||
)
|
||||
assert adjustment.quantity == 50
|
||||
|
||||
def test_negative_adjustment(self):
|
||||
"""Test negative quantity adjustment (remove stock)."""
|
||||
adjustment = InventoryAdjust(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=-20,
|
||||
)
|
||||
assert adjustment.quantity == -20
|
||||
|
||||
def test_zero_adjustment_is_valid(self):
|
||||
"""Test zero adjustment is technically valid."""
|
||||
adjustment = InventoryAdjust(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=0,
|
||||
)
|
||||
assert adjustment.quantity == 0
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryUpdateSchema:
|
||||
"""Test InventoryUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = InventoryUpdate(quantity=150)
|
||||
assert update.quantity == 150
|
||||
assert update.reserved_quantity is None
|
||||
assert update.location is None
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid."""
|
||||
update = InventoryUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
def test_quantity_must_be_non_negative(self):
|
||||
"""Test quantity must be >= 0 in update."""
|
||||
with pytest.raises(ValidationError):
|
||||
InventoryUpdate(quantity=-10)
|
||||
|
||||
def test_reserved_quantity_must_be_non_negative(self):
|
||||
"""Test reserved_quantity must be >= 0."""
|
||||
with pytest.raises(ValidationError):
|
||||
InventoryUpdate(reserved_quantity=-5)
|
||||
|
||||
def test_location_update(self):
|
||||
"""Test location can be updated."""
|
||||
update = InventoryUpdate(location="Warehouse B")
|
||||
assert update.location == "Warehouse B"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryReserveSchema:
|
||||
"""Test InventoryReserve schema validation."""
|
||||
|
||||
def test_valid_reservation(self):
|
||||
"""Test valid inventory reservation."""
|
||||
reservation = InventoryReserve(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=10,
|
||||
)
|
||||
assert reservation.product_id == 1
|
||||
assert reservation.quantity == 10
|
||||
|
||||
def test_quantity_must_be_positive(self):
|
||||
"""Test reservation quantity must be > 0."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
InventoryReserve(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=0,
|
||||
)
|
||||
assert "quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_negative_quantity_invalid(self):
|
||||
"""Test negative reservation quantity is invalid."""
|
||||
with pytest.raises(ValidationError):
|
||||
InventoryReserve(
|
||||
product_id=1,
|
||||
location="Warehouse A",
|
||||
quantity=-5,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryResponseSchema:
|
||||
"""Test InventoryResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"product_id": 1,
|
||||
"vendor_id": 1,
|
||||
"location": "Warehouse A",
|
||||
"quantity": 100,
|
||||
"reserved_quantity": 20,
|
||||
"gtin": "1234567890123",
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = InventoryResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.quantity == 100
|
||||
assert response.reserved_quantity == 20
|
||||
|
||||
def test_available_quantity_property(self):
|
||||
"""Test available_quantity calculated property."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"product_id": 1,
|
||||
"vendor_id": 1,
|
||||
"location": "Warehouse A",
|
||||
"quantity": 100,
|
||||
"reserved_quantity": 30,
|
||||
"gtin": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = InventoryResponse(**data)
|
||||
assert response.available_quantity == 70
|
||||
|
||||
def test_available_quantity_never_negative(self):
|
||||
"""Test available_quantity is never negative."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"product_id": 1,
|
||||
"vendor_id": 1,
|
||||
"location": "Warehouse A",
|
||||
"quantity": 10,
|
||||
"reserved_quantity": 50, # Over-reserved
|
||||
"gtin": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = InventoryResponse(**data)
|
||||
assert response.available_quantity == 0
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestInventoryLocationResponseSchema:
|
||||
"""Test InventoryLocationResponse schema."""
|
||||
|
||||
def test_valid_location_response(self):
|
||||
"""Test valid location response."""
|
||||
location = InventoryLocationResponse(
|
||||
location="Warehouse A",
|
||||
quantity=100,
|
||||
reserved_quantity=20,
|
||||
available_quantity=80,
|
||||
)
|
||||
assert location.location == "Warehouse A"
|
||||
assert location.quantity == 100
|
||||
assert location.available_quantity == 80
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestProductInventorySummarySchema:
|
||||
"""Test ProductInventorySummary schema."""
|
||||
|
||||
def test_valid_summary(self):
|
||||
"""Test valid inventory summary."""
|
||||
summary = ProductInventorySummary(
|
||||
product_id=1,
|
||||
vendor_id=1,
|
||||
product_sku="SKU-001",
|
||||
product_title="Test Product",
|
||||
total_quantity=200,
|
||||
total_reserved=50,
|
||||
total_available=150,
|
||||
locations=[
|
||||
InventoryLocationResponse(
|
||||
location="Warehouse A",
|
||||
quantity=100,
|
||||
reserved_quantity=25,
|
||||
available_quantity=75,
|
||||
),
|
||||
InventoryLocationResponse(
|
||||
location="Warehouse B",
|
||||
quantity=100,
|
||||
reserved_quantity=25,
|
||||
available_quantity=75,
|
||||
),
|
||||
],
|
||||
)
|
||||
assert summary.product_id == 1
|
||||
assert summary.total_quantity == 200
|
||||
assert len(summary.locations) == 2
|
||||
|
||||
def test_empty_locations(self):
|
||||
"""Test summary with no locations."""
|
||||
summary = ProductInventorySummary(
|
||||
product_id=1,
|
||||
vendor_id=1,
|
||||
product_sku=None,
|
||||
product_title="Test Product",
|
||||
total_quantity=0,
|
||||
total_reserved=0,
|
||||
total_available=0,
|
||||
locations=[],
|
||||
)
|
||||
assert summary.locations == []
|
||||
239
tests/unit/models/schema/test_marketplace_import_job.py
Normal file
239
tests/unit/models/schema/test_marketplace_import_job.py
Normal file
@@ -0,0 +1,239 @@
|
||||
# tests/unit/models/schema/test_marketplace_import_job.py
|
||||
"""Unit tests for marketplace import job Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.marketplace_import_job import (
|
||||
MarketplaceImportJobRequest,
|
||||
MarketplaceImportJobResponse,
|
||||
MarketplaceImportJobListResponse,
|
||||
MarketplaceImportJobStatusUpdate,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestMarketplaceImportJobRequestSchema:
|
||||
"""Test MarketplaceImportJobRequest schema validation."""
|
||||
|
||||
def test_valid_request(self):
|
||||
"""Test valid import job request."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
marketplace="Letzshop",
|
||||
)
|
||||
assert request.source_url == "https://example.com/products.csv"
|
||||
assert request.marketplace == "Letzshop"
|
||||
|
||||
def test_source_url_required(self):
|
||||
"""Test source_url is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
MarketplaceImportJobRequest(marketplace="Letzshop")
|
||||
assert "source_url" in str(exc_info.value).lower()
|
||||
|
||||
def test_source_url_must_be_http_or_https(self):
|
||||
"""Test source_url must start with http:// or https://."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
MarketplaceImportJobRequest(
|
||||
source_url="ftp://example.com/products.csv",
|
||||
)
|
||||
assert "url" in str(exc_info.value).lower()
|
||||
|
||||
def test_source_url_http_is_valid(self):
|
||||
"""Test http:// URLs are valid."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="http://example.com/products.csv",
|
||||
)
|
||||
assert request.source_url == "http://example.com/products.csv"
|
||||
|
||||
def test_source_url_with_leading_whitespace_invalid(self):
|
||||
"""Test source_url with leading whitespace is invalid (validation before strip)."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
MarketplaceImportJobRequest(
|
||||
source_url=" https://example.com/products.csv",
|
||||
)
|
||||
assert "url" in str(exc_info.value).lower()
|
||||
|
||||
def test_marketplace_default(self):
|
||||
"""Test marketplace defaults to Letzshop."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
)
|
||||
assert request.marketplace == "Letzshop"
|
||||
|
||||
def test_marketplace_stripped(self):
|
||||
"""Test marketplace is stripped of whitespace."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
marketplace=" CustomMarket ",
|
||||
)
|
||||
assert request.marketplace == "CustomMarket"
|
||||
|
||||
def test_batch_size_default(self):
|
||||
"""Test batch_size defaults to 1000."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
)
|
||||
assert request.batch_size == 1000
|
||||
|
||||
def test_batch_size_minimum(self):
|
||||
"""Test batch_size must be >= 100."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
batch_size=50,
|
||||
)
|
||||
assert "batch_size" in str(exc_info.value).lower()
|
||||
|
||||
def test_batch_size_maximum(self):
|
||||
"""Test batch_size must be <= 10000."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
batch_size=15000,
|
||||
)
|
||||
assert "batch_size" in str(exc_info.value).lower()
|
||||
|
||||
def test_batch_size_valid_range(self):
|
||||
"""Test batch_size in valid range."""
|
||||
request = MarketplaceImportJobRequest(
|
||||
source_url="https://example.com/products.csv",
|
||||
batch_size=5000,
|
||||
)
|
||||
assert request.batch_size == 5000
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestMarketplaceImportJobResponseSchema:
|
||||
"""Test MarketplaceImportJobResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"job_id": 1,
|
||||
"vendor_id": 1,
|
||||
"vendor_code": "TEST_VENDOR",
|
||||
"vendor_name": "Test Vendor",
|
||||
"marketplace": "Letzshop",
|
||||
"source_url": "https://example.com/products.csv",
|
||||
"status": "pending",
|
||||
"created_at": datetime.now(),
|
||||
}
|
||||
response = MarketplaceImportJobResponse(**data)
|
||||
assert response.job_id == 1
|
||||
assert response.vendor_code == "TEST_VENDOR"
|
||||
assert response.status == "pending"
|
||||
|
||||
def test_default_counts(self):
|
||||
"""Test count fields default to 0."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"job_id": 1,
|
||||
"vendor_id": 1,
|
||||
"vendor_code": "TEST_VENDOR",
|
||||
"vendor_name": "Test Vendor",
|
||||
"marketplace": "Letzshop",
|
||||
"source_url": "https://example.com/products.csv",
|
||||
"status": "completed",
|
||||
"created_at": datetime.now(),
|
||||
}
|
||||
response = MarketplaceImportJobResponse(**data)
|
||||
assert response.imported == 0
|
||||
assert response.updated == 0
|
||||
assert response.total_processed == 0
|
||||
assert response.error_count == 0
|
||||
|
||||
def test_optional_timestamps(self):
|
||||
"""Test optional timestamp fields."""
|
||||
from datetime import datetime
|
||||
|
||||
now = datetime.now()
|
||||
data = {
|
||||
"job_id": 1,
|
||||
"vendor_id": 1,
|
||||
"vendor_code": "TEST_VENDOR",
|
||||
"vendor_name": "Test Vendor",
|
||||
"marketplace": "Letzshop",
|
||||
"source_url": "https://example.com/products.csv",
|
||||
"status": "completed",
|
||||
"created_at": now,
|
||||
"started_at": now,
|
||||
"completed_at": now,
|
||||
}
|
||||
response = MarketplaceImportJobResponse(**data)
|
||||
assert response.started_at == now
|
||||
assert response.completed_at == now
|
||||
|
||||
def test_error_message_optional(self):
|
||||
"""Test error_message is optional."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"job_id": 1,
|
||||
"vendor_id": 1,
|
||||
"vendor_code": "TEST_VENDOR",
|
||||
"vendor_name": "Test Vendor",
|
||||
"marketplace": "Letzshop",
|
||||
"source_url": "https://example.com/products.csv",
|
||||
"status": "failed",
|
||||
"created_at": datetime.now(),
|
||||
"error_message": "Connection timeout",
|
||||
}
|
||||
response = MarketplaceImportJobResponse(**data)
|
||||
assert response.error_message == "Connection timeout"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestMarketplaceImportJobListResponseSchema:
|
||||
"""Test MarketplaceImportJobListResponse schema."""
|
||||
|
||||
def test_valid_list_response(self):
|
||||
"""Test valid list response structure."""
|
||||
response = MarketplaceImportJobListResponse(
|
||||
jobs=[],
|
||||
total=0,
|
||||
skip=0,
|
||||
limit=10,
|
||||
)
|
||||
assert response.jobs == []
|
||||
assert response.total == 0
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestMarketplaceImportJobStatusUpdateSchema:
|
||||
"""Test MarketplaceImportJobStatusUpdate schema."""
|
||||
|
||||
def test_status_only_update(self):
|
||||
"""Test update with only status."""
|
||||
update = MarketplaceImportJobStatusUpdate(status="processing")
|
||||
assert update.status == "processing"
|
||||
assert update.imported_count is None
|
||||
|
||||
def test_full_update(self):
|
||||
"""Test update with all fields."""
|
||||
update = MarketplaceImportJobStatusUpdate(
|
||||
status="completed",
|
||||
imported_count=100,
|
||||
updated_count=50,
|
||||
error_count=2,
|
||||
total_processed=152,
|
||||
)
|
||||
assert update.imported_count == 100
|
||||
assert update.updated_count == 50
|
||||
assert update.error_count == 2
|
||||
assert update.total_processed == 152
|
||||
|
||||
def test_error_update(self):
|
||||
"""Test update with error message."""
|
||||
update = MarketplaceImportJobStatusUpdate(
|
||||
status="failed",
|
||||
error_message="File not found",
|
||||
)
|
||||
assert update.status == "failed"
|
||||
assert update.error_message == "File not found"
|
||||
366
tests/unit/models/schema/test_order.py
Normal file
366
tests/unit/models/schema/test_order.py
Normal file
@@ -0,0 +1,366 @@
|
||||
# tests/unit/models/schema/test_order.py
|
||||
"""Unit tests for order Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.order import (
|
||||
OrderItemCreate,
|
||||
OrderItemResponse,
|
||||
OrderAddressCreate,
|
||||
OrderAddressResponse,
|
||||
OrderCreate,
|
||||
OrderUpdate,
|
||||
OrderResponse,
|
||||
OrderDetailResponse,
|
||||
OrderListResponse,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderItemCreateSchema:
|
||||
"""Test OrderItemCreate schema validation."""
|
||||
|
||||
def test_valid_order_item(self):
|
||||
"""Test valid order item creation."""
|
||||
item = OrderItemCreate(
|
||||
product_id=1,
|
||||
quantity=2,
|
||||
)
|
||||
assert item.product_id == 1
|
||||
assert item.quantity == 2
|
||||
|
||||
def test_product_id_required(self):
|
||||
"""Test product_id is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderItemCreate(quantity=2)
|
||||
assert "product_id" in str(exc_info.value).lower()
|
||||
|
||||
def test_quantity_required(self):
|
||||
"""Test quantity is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderItemCreate(product_id=1)
|
||||
assert "quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_quantity_must_be_at_least_1(self):
|
||||
"""Test quantity must be >= 1."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderItemCreate(
|
||||
product_id=1,
|
||||
quantity=0,
|
||||
)
|
||||
assert "quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_negative_quantity_invalid(self):
|
||||
"""Test negative quantity is invalid."""
|
||||
with pytest.raises(ValidationError):
|
||||
OrderItemCreate(
|
||||
product_id=1,
|
||||
quantity=-1,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderAddressCreateSchema:
|
||||
"""Test OrderAddressCreate schema validation."""
|
||||
|
||||
def test_valid_address(self):
|
||||
"""Test valid order address creation."""
|
||||
address = OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.first_name == "John"
|
||||
assert address.city == "Luxembourg"
|
||||
|
||||
def test_required_fields(self):
|
||||
"""Test required fields validation."""
|
||||
with pytest.raises(ValidationError):
|
||||
OrderAddressCreate(
|
||||
first_name="John",
|
||||
# missing required fields
|
||||
)
|
||||
|
||||
def test_optional_company(self):
|
||||
"""Test optional company field."""
|
||||
address = OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
company="Tech Corp",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.company == "Tech Corp"
|
||||
|
||||
def test_optional_address_line_2(self):
|
||||
"""Test optional address_line_2 field."""
|
||||
address = OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
address_line_2="Suite 500",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
assert address.address_line_2 == "Suite 500"
|
||||
|
||||
def test_first_name_min_length(self):
|
||||
"""Test first_name minimum length."""
|
||||
with pytest.raises(ValidationError):
|
||||
OrderAddressCreate(
|
||||
first_name="",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
)
|
||||
|
||||
def test_country_min_length(self):
|
||||
"""Test country minimum length (2)."""
|
||||
with pytest.raises(ValidationError):
|
||||
OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="L",
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderCreateSchema:
|
||||
"""Test OrderCreate schema validation."""
|
||||
|
||||
def test_valid_order(self):
|
||||
"""Test valid order creation."""
|
||||
order = OrderCreate(
|
||||
items=[
|
||||
OrderItemCreate(product_id=1, quantity=2),
|
||||
OrderItemCreate(product_id=2, quantity=1),
|
||||
],
|
||||
shipping_address=OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
),
|
||||
)
|
||||
assert len(order.items) == 2
|
||||
assert order.customer_id is None # Optional for guest checkout
|
||||
|
||||
def test_items_required(self):
|
||||
"""Test items are required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderCreate(
|
||||
shipping_address=OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
),
|
||||
)
|
||||
assert "items" in str(exc_info.value).lower()
|
||||
|
||||
def test_items_must_not_be_empty(self):
|
||||
"""Test items list must have at least 1 item."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderCreate(
|
||||
items=[],
|
||||
shipping_address=OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
),
|
||||
)
|
||||
assert "items" in str(exc_info.value).lower()
|
||||
|
||||
def test_shipping_address_required(self):
|
||||
"""Test shipping_address is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderCreate(
|
||||
items=[OrderItemCreate(product_id=1, quantity=1)],
|
||||
)
|
||||
assert "shipping_address" in str(exc_info.value).lower()
|
||||
|
||||
def test_optional_billing_address(self):
|
||||
"""Test billing_address is optional."""
|
||||
order = OrderCreate(
|
||||
items=[OrderItemCreate(product_id=1, quantity=1)],
|
||||
shipping_address=OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
),
|
||||
billing_address=OrderAddressCreate(
|
||||
first_name="Jane",
|
||||
last_name="Doe",
|
||||
address_line_1="456 Other St",
|
||||
city="Esch",
|
||||
postal_code="L-4321",
|
||||
country="Luxembourg",
|
||||
),
|
||||
)
|
||||
assert order.billing_address is not None
|
||||
assert order.billing_address.first_name == "Jane"
|
||||
|
||||
def test_optional_customer_notes(self):
|
||||
"""Test optional customer_notes."""
|
||||
order = OrderCreate(
|
||||
items=[OrderItemCreate(product_id=1, quantity=1)],
|
||||
shipping_address=OrderAddressCreate(
|
||||
first_name="John",
|
||||
last_name="Doe",
|
||||
address_line_1="123 Main St",
|
||||
city="Luxembourg",
|
||||
postal_code="L-1234",
|
||||
country="Luxembourg",
|
||||
),
|
||||
customer_notes="Please leave at door",
|
||||
)
|
||||
assert order.customer_notes == "Please leave at door"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderUpdateSchema:
|
||||
"""Test OrderUpdate schema validation."""
|
||||
|
||||
def test_status_update(self):
|
||||
"""Test valid status update."""
|
||||
update = OrderUpdate(status="processing")
|
||||
assert update.status == "processing"
|
||||
|
||||
def test_valid_status_values(self):
|
||||
"""Test all valid status values."""
|
||||
valid_statuses = ["pending", "processing", "shipped", "delivered", "cancelled", "refunded"]
|
||||
for status in valid_statuses:
|
||||
update = OrderUpdate(status=status)
|
||||
assert update.status == status
|
||||
|
||||
def test_invalid_status(self):
|
||||
"""Test invalid status raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
OrderUpdate(status="invalid_status")
|
||||
assert "status" in str(exc_info.value).lower()
|
||||
|
||||
def test_tracking_number_update(self):
|
||||
"""Test tracking number update."""
|
||||
update = OrderUpdate(tracking_number="TRACK123456")
|
||||
assert update.tracking_number == "TRACK123456"
|
||||
|
||||
def test_internal_notes_update(self):
|
||||
"""Test internal notes update."""
|
||||
update = OrderUpdate(internal_notes="Customer requested expedited shipping")
|
||||
assert update.internal_notes == "Customer requested expedited shipping"
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid."""
|
||||
update = OrderUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderResponseSchema:
|
||||
"""Test OrderResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_id": 1,
|
||||
"customer_id": 1,
|
||||
"order_number": "ORD-001",
|
||||
"status": "pending",
|
||||
"subtotal": 100.00,
|
||||
"tax_amount": 20.00,
|
||||
"shipping_amount": 10.00,
|
||||
"discount_amount": 5.00,
|
||||
"total_amount": 125.00,
|
||||
"currency": "EUR",
|
||||
"shipping_method": "standard",
|
||||
"tracking_number": None,
|
||||
"customer_notes": None,
|
||||
"internal_notes": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
"paid_at": None,
|
||||
"shipped_at": None,
|
||||
"delivered_at": None,
|
||||
"cancelled_at": None,
|
||||
}
|
||||
response = OrderResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.order_number == "ORD-001"
|
||||
assert response.total_amount == 125.00
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderItemResponseSchema:
|
||||
"""Test OrderItemResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"order_id": 1,
|
||||
"product_id": 1,
|
||||
"product_name": "Test Product",
|
||||
"product_sku": "SKU-001",
|
||||
"quantity": 2,
|
||||
"unit_price": 50.00,
|
||||
"total_price": 100.00,
|
||||
"inventory_reserved": True,
|
||||
"inventory_fulfilled": False,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = OrderItemResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.quantity == 2
|
||||
assert response.total_price == 100.00
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestOrderListResponseSchema:
|
||||
"""Test OrderListResponse schema."""
|
||||
|
||||
def test_valid_list_response(self):
|
||||
"""Test valid list response structure."""
|
||||
response = OrderListResponse(
|
||||
orders=[],
|
||||
total=0,
|
||||
skip=0,
|
||||
limit=10,
|
||||
)
|
||||
assert response.orders == []
|
||||
assert response.total == 0
|
||||
assert response.skip == 0
|
||||
assert response.limit == 10
|
||||
243
tests/unit/models/schema/test_product.py
Normal file
243
tests/unit/models/schema/test_product.py
Normal file
@@ -0,0 +1,243 @@
|
||||
# tests/unit/models/schema/test_product.py
|
||||
"""Unit tests for product Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.product import (
|
||||
ProductCreate,
|
||||
ProductUpdate,
|
||||
ProductResponse,
|
||||
ProductDetailResponse,
|
||||
ProductListResponse,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestProductCreateSchema:
|
||||
"""Test ProductCreate schema validation."""
|
||||
|
||||
def test_valid_product_create(self):
|
||||
"""Test valid product creation data."""
|
||||
product = ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
product_id="SKU-001",
|
||||
price=99.99,
|
||||
currency="EUR",
|
||||
)
|
||||
assert product.marketplace_product_id == 1
|
||||
assert product.product_id == "SKU-001"
|
||||
assert product.price == 99.99
|
||||
|
||||
def test_marketplace_product_id_required(self):
|
||||
"""Test marketplace_product_id is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
ProductCreate(price=99.99)
|
||||
assert "marketplace_product_id" in str(exc_info.value).lower()
|
||||
|
||||
def test_price_must_be_non_negative(self):
|
||||
"""Test price must be >= 0."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
price=-10.00,
|
||||
)
|
||||
assert "price" in str(exc_info.value).lower()
|
||||
|
||||
def test_price_zero_is_valid(self):
|
||||
"""Test price of 0 is valid."""
|
||||
product = ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
price=0,
|
||||
)
|
||||
assert product.price == 0
|
||||
|
||||
def test_sale_price_must_be_non_negative(self):
|
||||
"""Test sale_price must be >= 0."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
sale_price=-5.00,
|
||||
)
|
||||
assert "sale_price" in str(exc_info.value).lower()
|
||||
|
||||
def test_min_quantity_default(self):
|
||||
"""Test min_quantity defaults to 1."""
|
||||
product = ProductCreate(marketplace_product_id=1)
|
||||
assert product.min_quantity == 1
|
||||
|
||||
def test_min_quantity_must_be_at_least_1(self):
|
||||
"""Test min_quantity must be >= 1."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
min_quantity=0,
|
||||
)
|
||||
assert "min_quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_max_quantity_must_be_at_least_1(self):
|
||||
"""Test max_quantity must be >= 1 if provided."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
max_quantity=0,
|
||||
)
|
||||
assert "max_quantity" in str(exc_info.value).lower()
|
||||
|
||||
def test_is_featured_default(self):
|
||||
"""Test is_featured defaults to False."""
|
||||
product = ProductCreate(marketplace_product_id=1)
|
||||
assert product.is_featured is False
|
||||
|
||||
def test_all_optional_fields(self):
|
||||
"""Test product with all optional fields."""
|
||||
product = ProductCreate(
|
||||
marketplace_product_id=1,
|
||||
product_id="SKU-001",
|
||||
price=100.00,
|
||||
sale_price=80.00,
|
||||
currency="EUR",
|
||||
availability="in_stock",
|
||||
condition="new",
|
||||
is_featured=True,
|
||||
min_quantity=2,
|
||||
max_quantity=10,
|
||||
)
|
||||
assert product.sale_price == 80.00
|
||||
assert product.availability == "in_stock"
|
||||
assert product.condition == "new"
|
||||
assert product.is_featured is True
|
||||
assert product.max_quantity == 10
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestProductUpdateSchema:
|
||||
"""Test ProductUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = ProductUpdate(price=150.00)
|
||||
assert update.price == 150.00
|
||||
assert update.product_id is None
|
||||
assert update.is_active is None
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid (all fields optional)."""
|
||||
update = ProductUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
def test_price_validation(self):
|
||||
"""Test price must be >= 0 in update."""
|
||||
with pytest.raises(ValidationError):
|
||||
ProductUpdate(price=-10.00)
|
||||
|
||||
def test_is_active_update(self):
|
||||
"""Test is_active can be updated."""
|
||||
update = ProductUpdate(is_active=False)
|
||||
assert update.is_active is False
|
||||
|
||||
def test_is_featured_update(self):
|
||||
"""Test is_featured can be updated."""
|
||||
update = ProductUpdate(is_featured=True)
|
||||
assert update.is_featured is True
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestProductResponseSchema:
|
||||
"""Test ProductResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_id": 1,
|
||||
"marketplace_product": {
|
||||
"id": 1,
|
||||
"gtin": "1234567890123",
|
||||
"title": "Test Product",
|
||||
"description": "A test product",
|
||||
"brand": "Test Brand",
|
||||
"category": "Electronics",
|
||||
"image_url": "https://example.com/image.jpg",
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
},
|
||||
"product_id": "SKU-001",
|
||||
"price": 99.99,
|
||||
"sale_price": None,
|
||||
"currency": "EUR",
|
||||
"availability": "in_stock",
|
||||
"condition": "new",
|
||||
"is_featured": False,
|
||||
"is_active": True,
|
||||
"display_order": 0,
|
||||
"min_quantity": 1,
|
||||
"max_quantity": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = ProductResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.vendor_id == 1
|
||||
assert response.is_active is True
|
||||
|
||||
def test_optional_inventory_fields(self):
|
||||
"""Test optional inventory summary fields."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_id": 1,
|
||||
"marketplace_product": {
|
||||
"id": 1,
|
||||
"gtin": "1234567890123",
|
||||
"title": "Test Product",
|
||||
"description": None,
|
||||
"brand": None,
|
||||
"category": None,
|
||||
"image_url": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
},
|
||||
"product_id": None,
|
||||
"price": None,
|
||||
"sale_price": None,
|
||||
"currency": None,
|
||||
"availability": None,
|
||||
"condition": None,
|
||||
"is_featured": False,
|
||||
"is_active": True,
|
||||
"display_order": 0,
|
||||
"min_quantity": 1,
|
||||
"max_quantity": None,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
"total_inventory": 100,
|
||||
"available_inventory": 80,
|
||||
}
|
||||
response = ProductResponse(**data)
|
||||
assert response.total_inventory == 100
|
||||
assert response.available_inventory == 80
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestProductListResponseSchema:
|
||||
"""Test ProductListResponse schema."""
|
||||
|
||||
def test_valid_list_response(self):
|
||||
"""Test valid list response structure."""
|
||||
response = ProductListResponse(
|
||||
products=[],
|
||||
total=0,
|
||||
skip=0,
|
||||
limit=10,
|
||||
)
|
||||
assert response.products == []
|
||||
assert response.total == 0
|
||||
assert response.skip == 0
|
||||
assert response.limit == 10
|
||||
315
tests/unit/models/schema/test_vendor.py
Normal file
315
tests/unit/models/schema/test_vendor.py
Normal file
@@ -0,0 +1,315 @@
|
||||
# tests/unit/models/schema/test_vendor.py
|
||||
"""Unit tests for vendor Pydantic schemas."""
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from models.schema.vendor import (
|
||||
VendorCreate,
|
||||
VendorUpdate,
|
||||
VendorResponse,
|
||||
VendorDetailResponse,
|
||||
VendorListResponse,
|
||||
VendorSummary,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorCreateSchema:
|
||||
"""Test VendorCreate schema validation."""
|
||||
|
||||
def test_valid_vendor_create(self):
|
||||
"""Test valid vendor creation data."""
|
||||
vendor = VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert vendor.company_id == 1
|
||||
assert vendor.vendor_code == "TECHSTORE"
|
||||
assert vendor.subdomain == "techstore"
|
||||
assert vendor.name == "Tech Store"
|
||||
|
||||
def test_company_id_required(self):
|
||||
"""Test company_id is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "company_id" in str(exc_info.value).lower()
|
||||
|
||||
def test_company_id_must_be_positive(self):
|
||||
"""Test company_id must be > 0."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=0,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "company_id" in str(exc_info.value).lower()
|
||||
|
||||
def test_vendor_code_required(self):
|
||||
"""Test vendor_code is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "vendor_code" in str(exc_info.value).lower()
|
||||
|
||||
def test_vendor_code_uppercase_normalized(self):
|
||||
"""Test vendor_code is normalized to uppercase."""
|
||||
vendor = VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="techstore",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert vendor.vendor_code == "TECHSTORE"
|
||||
|
||||
def test_vendor_code_min_length(self):
|
||||
"""Test vendor_code minimum length (2)."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="T",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "vendor_code" in str(exc_info.value).lower()
|
||||
|
||||
def test_subdomain_required(self):
|
||||
"""Test subdomain is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "subdomain" in str(exc_info.value).lower()
|
||||
|
||||
def test_subdomain_uppercase_invalid(self):
|
||||
"""Test subdomain with uppercase is invalid (validated before normalization)."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="TechStore",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "subdomain" in str(exc_info.value).lower()
|
||||
|
||||
def test_subdomain_valid_format(self):
|
||||
"""Test subdomain with valid format."""
|
||||
vendor = VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="tech-store-123",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert vendor.subdomain == "tech-store-123"
|
||||
|
||||
def test_subdomain_invalid_format(self):
|
||||
"""Test subdomain with invalid characters raises ValidationError."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="tech_store!",
|
||||
name="Tech Store",
|
||||
)
|
||||
assert "subdomain" in str(exc_info.value).lower()
|
||||
|
||||
def test_name_required(self):
|
||||
"""Test name is required."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
)
|
||||
assert "name" in str(exc_info.value).lower()
|
||||
|
||||
def test_name_min_length(self):
|
||||
"""Test name minimum length (2)."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
name="T",
|
||||
)
|
||||
assert "name" in str(exc_info.value).lower()
|
||||
|
||||
def test_optional_fields(self):
|
||||
"""Test optional fields."""
|
||||
vendor = VendorCreate(
|
||||
company_id=1,
|
||||
vendor_code="TECHSTORE",
|
||||
subdomain="techstore",
|
||||
name="Tech Store",
|
||||
description="Best tech store",
|
||||
letzshop_csv_url_fr="https://example.com/fr.csv",
|
||||
contact_email="contact@techstore.com",
|
||||
website="https://techstore.com",
|
||||
)
|
||||
assert vendor.description == "Best tech store"
|
||||
assert vendor.letzshop_csv_url_fr == "https://example.com/fr.csv"
|
||||
assert vendor.contact_email == "contact@techstore.com"
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorUpdateSchema:
|
||||
"""Test VendorUpdate schema validation."""
|
||||
|
||||
def test_partial_update(self):
|
||||
"""Test partial update with only some fields."""
|
||||
update = VendorUpdate(name="New Tech Store")
|
||||
assert update.name == "New Tech Store"
|
||||
assert update.subdomain is None
|
||||
assert update.is_active is None
|
||||
|
||||
def test_empty_update_is_valid(self):
|
||||
"""Test empty update is valid."""
|
||||
update = VendorUpdate()
|
||||
assert update.model_dump(exclude_unset=True) == {}
|
||||
|
||||
def test_subdomain_normalized_to_lowercase(self):
|
||||
"""Test subdomain is normalized to lowercase."""
|
||||
update = VendorUpdate(subdomain="NewSubdomain")
|
||||
assert update.subdomain == "newsubdomain"
|
||||
|
||||
def test_subdomain_stripped(self):
|
||||
"""Test subdomain is stripped of whitespace."""
|
||||
update = VendorUpdate(subdomain=" newsubdomain ")
|
||||
assert update.subdomain == "newsubdomain"
|
||||
|
||||
def test_name_min_length(self):
|
||||
"""Test name minimum length (2)."""
|
||||
with pytest.raises(ValidationError):
|
||||
VendorUpdate(name="X")
|
||||
|
||||
def test_is_active_update(self):
|
||||
"""Test is_active can be updated."""
|
||||
update = VendorUpdate(is_active=False)
|
||||
assert update.is_active is False
|
||||
|
||||
def test_is_verified_update(self):
|
||||
"""Test is_verified can be updated."""
|
||||
update = VendorUpdate(is_verified=True)
|
||||
assert update.is_verified is True
|
||||
|
||||
def test_reset_contact_to_company_flag(self):
|
||||
"""Test reset_contact_to_company flag."""
|
||||
update = VendorUpdate(reset_contact_to_company=True)
|
||||
assert update.reset_contact_to_company is True
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorResponseSchema:
|
||||
"""Test VendorResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_code": "TECHSTORE",
|
||||
"subdomain": "techstore",
|
||||
"name": "Tech Store",
|
||||
"description": "Best tech store",
|
||||
"company_id": 1,
|
||||
"letzshop_csv_url_fr": None,
|
||||
"letzshop_csv_url_en": None,
|
||||
"letzshop_csv_url_de": None,
|
||||
"is_active": True,
|
||||
"is_verified": False,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
}
|
||||
response = VendorResponse(**data)
|
||||
assert response.id == 1
|
||||
assert response.vendor_code == "TECHSTORE"
|
||||
assert response.is_active is True
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorDetailResponseSchema:
|
||||
"""Test VendorDetailResponse schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating detail response from dict."""
|
||||
from datetime import datetime
|
||||
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_code": "TECHSTORE",
|
||||
"subdomain": "techstore",
|
||||
"name": "Tech Store",
|
||||
"description": None,
|
||||
"company_id": 1,
|
||||
"letzshop_csv_url_fr": None,
|
||||
"letzshop_csv_url_en": None,
|
||||
"letzshop_csv_url_de": None,
|
||||
"is_active": True,
|
||||
"is_verified": True,
|
||||
"created_at": datetime.now(),
|
||||
"updated_at": datetime.now(),
|
||||
# Additional detail fields
|
||||
"company_name": "Tech Corp",
|
||||
"owner_email": "owner@techcorp.com",
|
||||
"owner_username": "owner",
|
||||
"contact_email": "contact@techstore.com",
|
||||
"contact_email_inherited": False,
|
||||
}
|
||||
response = VendorDetailResponse(**data)
|
||||
assert response.company_name == "Tech Corp"
|
||||
assert response.owner_email == "owner@techcorp.com"
|
||||
assert response.contact_email_inherited is False
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorListResponseSchema:
|
||||
"""Test VendorListResponse schema."""
|
||||
|
||||
def test_valid_list_response(self):
|
||||
"""Test valid list response structure."""
|
||||
response = VendorListResponse(
|
||||
vendors=[],
|
||||
total=0,
|
||||
skip=0,
|
||||
limit=10,
|
||||
)
|
||||
assert response.vendors == []
|
||||
assert response.total == 0
|
||||
|
||||
|
||||
@pytest.mark.unit
|
||||
@pytest.mark.schema
|
||||
class TestVendorSummarySchema:
|
||||
"""Test VendorSummary schema."""
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating summary from dict."""
|
||||
data = {
|
||||
"id": 1,
|
||||
"vendor_code": "TECHSTORE",
|
||||
"subdomain": "techstore",
|
||||
"name": "Tech Store",
|
||||
"company_id": 1,
|
||||
"is_active": True,
|
||||
}
|
||||
summary = VendorSummary(**data)
|
||||
assert summary.id == 1
|
||||
assert summary.vendor_code == "TECHSTORE"
|
||||
assert summary.is_active is True
|
||||
Reference in New Issue
Block a user