mirror of
https://github.com/pacnpal/thrillwiki_django_no_react.git
synced 2025-12-23 06:51:09 -05:00
574 lines
19 KiB
Python
574 lines
19 KiB
Python
"""
|
|
Tests for Ride serializers.
|
|
|
|
Following Django styleguide pattern: test__<context>__<action>__<expected_outcome>
|
|
"""
|
|
|
|
import pytest
|
|
from unittest.mock import Mock, MagicMock
|
|
from django.test import TestCase
|
|
|
|
from apps.api.v1.rides.serializers import (
|
|
RidePhotoOutputSerializer,
|
|
RidePhotoCreateInputSerializer,
|
|
RidePhotoUpdateInputSerializer,
|
|
RidePhotoListOutputSerializer,
|
|
RidePhotoApprovalInputSerializer,
|
|
RidePhotoStatsOutputSerializer,
|
|
RidePhotoTypeFilterSerializer,
|
|
RidePhotoSerializer,
|
|
HybridRideSerializer,
|
|
RideSerializer,
|
|
)
|
|
|
|
from tests.factories import (
|
|
RideFactory,
|
|
RidePhotoFactory,
|
|
ParkFactory,
|
|
UserFactory,
|
|
CloudflareImageFactory,
|
|
ManufacturerCompanyFactory,
|
|
DesignerCompanyFactory,
|
|
)
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRidePhotoOutputSerializer(TestCase):
|
|
"""Tests for RidePhotoOutputSerializer."""
|
|
|
|
def test__serialize__valid_photo__returns_all_fields(self):
|
|
"""Test serializing a ride photo returns all expected fields."""
|
|
user = UserFactory()
|
|
ride = RideFactory()
|
|
image = CloudflareImageFactory()
|
|
photo = RidePhotoFactory(
|
|
ride=ride,
|
|
uploaded_by=user,
|
|
image=image,
|
|
caption="Test caption",
|
|
alt_text="Test alt text",
|
|
is_primary=True,
|
|
is_approved=True,
|
|
)
|
|
|
|
serializer = RidePhotoOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert "id" in data
|
|
assert data["caption"] == "Test caption"
|
|
assert data["alt_text"] == "Test alt text"
|
|
assert data["is_primary"] is True
|
|
assert data["is_approved"] is True
|
|
assert data["uploaded_by_username"] == user.username
|
|
assert data["ride_slug"] == ride.slug
|
|
assert data["ride_name"] == ride.name
|
|
assert data["park_slug"] == ride.park.slug
|
|
assert data["park_name"] == ride.park.name
|
|
|
|
def test__serialize__photo_with_image__returns_image_url(self):
|
|
"""Test serializing a photo with image returns URL."""
|
|
photo = RidePhotoFactory()
|
|
|
|
serializer = RidePhotoOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert "image_url" in data
|
|
assert "image_variants" in data
|
|
|
|
def test__serialize__photo_without_image__returns_none_for_image_fields(self):
|
|
"""Test serializing photo without image returns None for image fields."""
|
|
photo = RidePhotoFactory()
|
|
photo.image = None
|
|
photo.save()
|
|
|
|
serializer = RidePhotoOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert data["image_url"] is None
|
|
assert data["image_variants"] == {}
|
|
|
|
def test__get_image_variants__photo_with_image__returns_variant_urls(self):
|
|
"""Test get_image_variants returns all variant URLs."""
|
|
image = CloudflareImageFactory()
|
|
photo = RidePhotoFactory(image=image)
|
|
|
|
serializer = RidePhotoOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
if photo.image:
|
|
variants = data["image_variants"]
|
|
assert "thumbnail" in variants
|
|
assert "medium" in variants
|
|
assert "large" in variants
|
|
assert "public" in variants
|
|
|
|
def test__serialize__includes_photo_type(self):
|
|
"""Test serializing includes photo_type field."""
|
|
photo = RidePhotoFactory()
|
|
|
|
serializer = RidePhotoOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert "photo_type" in data
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRidePhotoCreateInputSerializer(TestCase):
|
|
"""Tests for RidePhotoCreateInputSerializer."""
|
|
|
|
def test__serialize__valid_data__returns_expected_fields(self):
|
|
"""Test serializing valid create data."""
|
|
image = CloudflareImageFactory()
|
|
data = {
|
|
"image": image.pk,
|
|
"caption": "New photo caption",
|
|
"alt_text": "Description of the image",
|
|
"photo_type": "exterior",
|
|
"is_primary": False,
|
|
}
|
|
|
|
serializer = RidePhotoCreateInputSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert "caption" in serializer.validated_data
|
|
assert "alt_text" in serializer.validated_data
|
|
assert "photo_type" in serializer.validated_data
|
|
assert "is_primary" in serializer.validated_data
|
|
|
|
def test__validate__missing_required_fields__returns_error(self):
|
|
"""Test validation fails with missing required fields."""
|
|
data = {}
|
|
|
|
serializer = RidePhotoCreateInputSerializer(data=data)
|
|
|
|
assert not serializer.is_valid()
|
|
|
|
def test__meta__fields__includes_photo_type(self):
|
|
"""Test Meta.fields includes photo_type for ride photos."""
|
|
expected_fields = ["image", "caption", "alt_text", "photo_type", "is_primary"]
|
|
|
|
assert list(RidePhotoCreateInputSerializer.Meta.fields) == expected_fields
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRidePhotoUpdateInputSerializer(TestCase):
|
|
"""Tests for RidePhotoUpdateInputSerializer."""
|
|
|
|
def test__serialize__valid_data__returns_expected_fields(self):
|
|
"""Test serializing valid update data."""
|
|
data = {
|
|
"caption": "Updated caption",
|
|
"alt_text": "Updated alt text",
|
|
"photo_type": "queue",
|
|
"is_primary": True,
|
|
}
|
|
|
|
serializer = RidePhotoUpdateInputSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert serializer.validated_data["caption"] == "Updated caption"
|
|
assert serializer.validated_data["photo_type"] == "queue"
|
|
|
|
def test__serialize__partial_update__validates_partial_data(self):
|
|
"""Test partial update with only some fields."""
|
|
photo = RidePhotoFactory()
|
|
data = {"caption": "Only caption updated"}
|
|
|
|
serializer = RidePhotoUpdateInputSerializer(photo, data=data, partial=True)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
|
|
def test__meta__fields__includes_photo_type(self):
|
|
"""Test Meta.fields includes photo_type for updates."""
|
|
expected_fields = ["caption", "alt_text", "photo_type", "is_primary"]
|
|
|
|
assert list(RidePhotoUpdateInputSerializer.Meta.fields) == expected_fields
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRidePhotoListOutputSerializer(TestCase):
|
|
"""Tests for RidePhotoListOutputSerializer."""
|
|
|
|
def test__serialize__photo__returns_list_fields_only(self):
|
|
"""Test serializing returns only list-appropriate fields."""
|
|
user = UserFactory()
|
|
photo = RidePhotoFactory(uploaded_by=user)
|
|
|
|
serializer = RidePhotoListOutputSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert "id" in data
|
|
assert "image" in data
|
|
assert "caption" in data
|
|
assert "photo_type" in data
|
|
assert "is_primary" in data
|
|
assert "is_approved" in data
|
|
assert "created_at" in data
|
|
assert "uploaded_by_username" in data
|
|
# Should NOT include detailed fields
|
|
assert "image_variants" not in data
|
|
assert "file_size" not in data
|
|
assert "dimensions" not in data
|
|
|
|
def test__serialize__multiple_photos__returns_list(self):
|
|
"""Test serializing multiple photos returns a list."""
|
|
photos = [RidePhotoFactory() for _ in range(3)]
|
|
|
|
serializer = RidePhotoListOutputSerializer(photos, many=True)
|
|
|
|
assert len(serializer.data) == 3
|
|
|
|
def test__meta__all_fields_read_only(self):
|
|
"""Test all fields are read-only for list serializer."""
|
|
assert (
|
|
RidePhotoListOutputSerializer.Meta.read_only_fields
|
|
== RidePhotoListOutputSerializer.Meta.fields
|
|
)
|
|
|
|
|
|
class TestRidePhotoApprovalInputSerializer(TestCase):
|
|
"""Tests for RidePhotoApprovalInputSerializer."""
|
|
|
|
def test__validate__valid_photo_ids__returns_validated_data(self):
|
|
"""Test validation with valid photo IDs."""
|
|
data = {
|
|
"photo_ids": [1, 2, 3],
|
|
"approve": True,
|
|
}
|
|
|
|
serializer = RidePhotoApprovalInputSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert serializer.validated_data["photo_ids"] == [1, 2, 3]
|
|
assert serializer.validated_data["approve"] is True
|
|
|
|
def test__validate__approve_default__defaults_to_true(self):
|
|
"""Test approve field defaults to True."""
|
|
data = {"photo_ids": [1, 2]}
|
|
|
|
serializer = RidePhotoApprovalInputSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert serializer.validated_data["approve"] is True
|
|
|
|
def test__validate__empty_photo_ids__is_valid(self):
|
|
"""Test empty photo_ids list is valid."""
|
|
data = {"photo_ids": [], "approve": False}
|
|
|
|
serializer = RidePhotoApprovalInputSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
|
|
def test__validate__missing_photo_ids__returns_error(self):
|
|
"""Test validation fails without photo_ids."""
|
|
data = {"approve": True}
|
|
|
|
serializer = RidePhotoApprovalInputSerializer(data=data)
|
|
|
|
assert not serializer.is_valid()
|
|
assert "photo_ids" in serializer.errors
|
|
|
|
|
|
class TestRidePhotoStatsOutputSerializer(TestCase):
|
|
"""Tests for RidePhotoStatsOutputSerializer."""
|
|
|
|
def test__serialize__stats_dict__returns_all_fields(self):
|
|
"""Test serializing stats dictionary."""
|
|
stats = {
|
|
"total_photos": 50,
|
|
"approved_photos": 40,
|
|
"pending_photos": 10,
|
|
"has_primary": True,
|
|
"recent_uploads": 3,
|
|
"by_type": {"exterior": 20, "queue": 10, "onride": 10, "other": 10},
|
|
}
|
|
|
|
serializer = RidePhotoStatsOutputSerializer(data=stats)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert serializer.validated_data["total_photos"] == 50
|
|
assert serializer.validated_data["by_type"]["exterior"] == 20
|
|
|
|
def test__validate__includes_by_type_field(self):
|
|
"""Test stats include by_type breakdown."""
|
|
stats = {
|
|
"total_photos": 10,
|
|
"approved_photos": 8,
|
|
"pending_photos": 2,
|
|
"has_primary": False,
|
|
"recent_uploads": 1,
|
|
"by_type": {"exterior": 10},
|
|
}
|
|
|
|
serializer = RidePhotoStatsOutputSerializer(data=stats)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert "by_type" in serializer.validated_data
|
|
|
|
|
|
class TestRidePhotoTypeFilterSerializer(TestCase):
|
|
"""Tests for RidePhotoTypeFilterSerializer."""
|
|
|
|
def test__validate__valid_photo_type__returns_validated_data(self):
|
|
"""Test validation with valid photo type."""
|
|
data = {"photo_type": "exterior"}
|
|
|
|
serializer = RidePhotoTypeFilterSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
assert serializer.validated_data["photo_type"] == "exterior"
|
|
|
|
def test__validate__all_photo_types__are_valid(self):
|
|
"""Test all defined photo types are valid."""
|
|
valid_types = ["exterior", "queue", "station", "onride", "construction", "other"]
|
|
|
|
for photo_type in valid_types:
|
|
serializer = RidePhotoTypeFilterSerializer(data={"photo_type": photo_type})
|
|
assert serializer.is_valid(), f"Photo type {photo_type} should be valid"
|
|
|
|
def test__validate__invalid_photo_type__returns_error(self):
|
|
"""Test invalid photo type returns error."""
|
|
data = {"photo_type": "invalid_type"}
|
|
|
|
serializer = RidePhotoTypeFilterSerializer(data=data)
|
|
|
|
assert not serializer.is_valid()
|
|
assert "photo_type" in serializer.errors
|
|
|
|
def test__validate__empty_photo_type__is_valid(self):
|
|
"""Test empty/missing photo_type is valid (optional field)."""
|
|
data = {}
|
|
|
|
serializer = RidePhotoTypeFilterSerializer(data=data)
|
|
|
|
assert serializer.is_valid(), serializer.errors
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestHybridRideSerializer(TestCase):
|
|
"""Tests for HybridRideSerializer."""
|
|
|
|
def test__serialize__ride_with_all_fields__returns_complete_data(self):
|
|
"""Test serializing ride with all fields populated."""
|
|
ride = RideFactory()
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
data = serializer.data
|
|
|
|
assert "id" in data
|
|
assert "name" in data
|
|
assert "slug" in data
|
|
assert "category" in data
|
|
assert "status" in data
|
|
assert "park_name" in data
|
|
assert "park_slug" in data
|
|
assert "manufacturer_name" in data
|
|
|
|
def test__serialize__ride_with_manufacturer__returns_manufacturer_fields(self):
|
|
"""Test serializing includes manufacturer information."""
|
|
manufacturer = ManufacturerCompanyFactory(name="Test Manufacturer")
|
|
ride = RideFactory(manufacturer=manufacturer)
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
data = serializer.data
|
|
|
|
assert data["manufacturer_name"] == "Test Manufacturer"
|
|
assert "manufacturer_slug" in data
|
|
|
|
def test__serialize__ride_with_designer__returns_designer_fields(self):
|
|
"""Test serializing includes designer information."""
|
|
designer = DesignerCompanyFactory(name="Test Designer")
|
|
ride = RideFactory(designer=designer)
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
data = serializer.data
|
|
|
|
assert data["designer_name"] == "Test Designer"
|
|
assert "designer_slug" in data
|
|
|
|
def test__get_park_city__ride_with_park_location__returns_city(self):
|
|
"""Test get_park_city returns city from park location."""
|
|
ride = RideFactory()
|
|
|
|
mock_location = Mock()
|
|
mock_location.city = "Orlando"
|
|
mock_location.state = "FL"
|
|
mock_location.country = "USA"
|
|
|
|
ride.park.location = mock_location
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_park_city(ride) == "Orlando"
|
|
|
|
def test__get_park_city__ride_without_park_location__returns_none(self):
|
|
"""Test get_park_city returns None when no location."""
|
|
ride = RideFactory()
|
|
ride.park.location = None
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_park_city(ride) is None
|
|
|
|
def test__get_coaster_height_ft__ride_with_stats__returns_height(self):
|
|
"""Test get_coaster_height_ft returns height from coaster stats."""
|
|
ride = RideFactory()
|
|
|
|
mock_stats = Mock()
|
|
mock_stats.height_ft = 205.5
|
|
mock_stats.length_ft = 5000
|
|
mock_stats.speed_mph = 70
|
|
mock_stats.inversions = 4
|
|
|
|
ride.coaster_stats = mock_stats
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_coaster_height_ft(ride) == 205.5
|
|
|
|
def test__get_coaster_inversions__ride_with_stats__returns_inversions(self):
|
|
"""Test get_coaster_inversions returns inversions count."""
|
|
ride = RideFactory()
|
|
|
|
mock_stats = Mock()
|
|
mock_stats.inversions = 7
|
|
|
|
ride.coaster_stats = mock_stats
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_coaster_inversions(ride) == 7
|
|
|
|
def test__get_coaster_height_ft__ride_without_stats__returns_none(self):
|
|
"""Test coaster stat methods return None when no stats."""
|
|
ride = RideFactory()
|
|
ride.coaster_stats = None
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_coaster_height_ft(ride) is None
|
|
assert serializer.get_coaster_length_ft(ride) is None
|
|
assert serializer.get_coaster_speed_mph(ride) is None
|
|
assert serializer.get_coaster_inversions(ride) is None
|
|
|
|
def test__get_banner_image_url__ride_with_banner__returns_url(self):
|
|
"""Test get_banner_image_url returns URL when banner exists."""
|
|
ride = RideFactory()
|
|
|
|
mock_image = Mock()
|
|
mock_image.url = "https://example.com/ride-banner.jpg"
|
|
|
|
mock_banner = Mock()
|
|
mock_banner.image = mock_image
|
|
|
|
ride.banner_image = mock_banner
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_banner_image_url(ride) == "https://example.com/ride-banner.jpg"
|
|
|
|
def test__get_banner_image_url__ride_without_banner__returns_none(self):
|
|
"""Test get_banner_image_url returns None when no banner."""
|
|
ride = RideFactory()
|
|
ride.banner_image = None
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
|
|
assert serializer.get_banner_image_url(ride) is None
|
|
|
|
def test__meta__all_fields_read_only(self):
|
|
"""Test all fields in HybridRideSerializer are read-only."""
|
|
assert (
|
|
HybridRideSerializer.Meta.read_only_fields
|
|
== HybridRideSerializer.Meta.fields
|
|
)
|
|
|
|
def test__serialize__includes_ride_model_fields(self):
|
|
"""Test serializing includes ride model information."""
|
|
ride = RideFactory()
|
|
|
|
serializer = HybridRideSerializer(ride)
|
|
data = serializer.data
|
|
|
|
assert "ride_model_name" in data
|
|
assert "ride_model_slug" in data
|
|
assert "ride_model_category" in data
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRideSerializer(TestCase):
|
|
"""Tests for RideSerializer (legacy)."""
|
|
|
|
def test__serialize__ride__returns_basic_fields(self):
|
|
"""Test serializing ride returns basic fields."""
|
|
ride = RideFactory()
|
|
|
|
serializer = RideSerializer(ride)
|
|
data = serializer.data
|
|
|
|
assert "id" in data
|
|
assert "name" in data
|
|
assert "slug" in data
|
|
assert "category" in data
|
|
assert "status" in data
|
|
assert "opening_date" in data
|
|
|
|
def test__serialize__multiple_rides__returns_list(self):
|
|
"""Test serializing multiple rides returns a list."""
|
|
rides = [RideFactory() for _ in range(3)]
|
|
|
|
serializer = RideSerializer(rides, many=True)
|
|
|
|
assert len(serializer.data) == 3
|
|
|
|
def test__meta__fields__matches_expected(self):
|
|
"""Test Meta.fields matches expected field list."""
|
|
expected_fields = [
|
|
"id",
|
|
"name",
|
|
"slug",
|
|
"park",
|
|
"manufacturer",
|
|
"designer",
|
|
"category",
|
|
"status",
|
|
"opening_date",
|
|
"closing_date",
|
|
]
|
|
|
|
assert list(RideSerializer.Meta.fields) == expected_fields
|
|
|
|
|
|
@pytest.mark.django_db
|
|
class TestRidePhotoSerializer(TestCase):
|
|
"""Tests for legacy RidePhotoSerializer."""
|
|
|
|
def test__serialize__photo__returns_legacy_fields(self):
|
|
"""Test serializing photo returns legacy field set."""
|
|
photo = RidePhotoFactory()
|
|
|
|
serializer = RidePhotoSerializer(photo)
|
|
data = serializer.data
|
|
|
|
assert "id" in data
|
|
assert "image" in data
|
|
assert "caption" in data
|
|
assert "alt_text" in data
|
|
assert "is_primary" in data
|
|
assert "photo_type" in data
|
|
|
|
def test__meta__fields__matches_legacy_format(self):
|
|
"""Test Meta.fields matches legacy format."""
|
|
expected_fields = [
|
|
"id",
|
|
"image",
|
|
"caption",
|
|
"alt_text",
|
|
"is_primary",
|
|
"photo_type",
|
|
"uploaded_at",
|
|
"uploaded_by",
|
|
]
|
|
|
|
assert list(RidePhotoSerializer.Meta.fields) == expected_fields
|