mirror of
https://github.com/pacnpal/thrillwiki_django_no_react.git
synced 2025-12-20 13:11:08 -05:00
d504d41de2
- Add complete backend/ directory with full Django application - Add frontend/ directory with Vite + TypeScript setup ready for Next.js - Add comprehensive shared/ directory with: - Complete documentation and memory-bank archives - Media files and avatars (letters, park/ride images) - Deployment scripts and automation tools - Shared types and utilities - Add architecture/ directory with migration guides - Configure pnpm workspace for monorepo development - Update .gitignore to exclude .django_tailwind_cli/ build artifacts - Preserve all historical documentation in shared/docs/memory-bank/ - Set up proper structure for full-stack development with shared resources
245 lines
8.6 KiB
Python
245 lines
8.6 KiB
Python
"""
|
|
Test cases demonstrating the factory pattern usage.
|
|
Following Django styleguide pattern for test data creation.
|
|
"""
|
|
|
|
from django.test import TestCase
|
|
from django.contrib.auth import get_user_model
|
|
|
|
from .factories import (
|
|
UserFactory,
|
|
ParkFactory,
|
|
RideFactory,
|
|
ParkReviewFactory,
|
|
RideReviewFactory,
|
|
CompanyFactory,
|
|
Traits,
|
|
)
|
|
|
|
User = get_user_model()
|
|
|
|
|
|
class FactoryTestCase(TestCase):
|
|
"""Test case demonstrating factory usage patterns."""
|
|
|
|
def test_user_factory_basic(self):
|
|
"""Test basic user factory functionality."""
|
|
# Build without saving to database
|
|
user = UserFactory.build()
|
|
self.assertIsInstance(user, User)
|
|
self.assertTrue(user.username.startswith("testuser"))
|
|
self.assertIn("@example.com", user.email)
|
|
|
|
# Create and save to database
|
|
user = UserFactory()
|
|
self.assertTrue(user.pk)
|
|
self.assertTrue(user.check_password("testpass123"))
|
|
|
|
def test_user_factory_with_custom_password(self):
|
|
"""Test user factory with custom password."""
|
|
user = UserFactory(set_password__password="custompass")
|
|
self.assertTrue(user.check_password("custompass"))
|
|
|
|
def test_staff_user_factory(self):
|
|
"""Test staff user factory."""
|
|
from .factories import StaffUserFactory
|
|
|
|
staff = StaffUserFactory()
|
|
self.assertTrue(staff.is_staff)
|
|
self.assertFalse(staff.is_superuser)
|
|
|
|
def test_company_factory_with_roles(self):
|
|
"""Test company factory with different roles."""
|
|
# Operator company
|
|
operator = CompanyFactory(roles=["OPERATOR"])
|
|
self.assertEqual(operator.roles, ["OPERATOR"])
|
|
|
|
# Manufacturer company
|
|
manufacturer = CompanyFactory(roles=["MANUFACTURER"])
|
|
self.assertEqual(manufacturer.roles, ["MANUFACTURER"])
|
|
|
|
# Multi-role company
|
|
multi_role = CompanyFactory(roles=["OPERATOR", "MANUFACTURER"])
|
|
self.assertEqual(set(multi_role.roles), {"OPERATOR", "MANUFACTURER"})
|
|
|
|
def test_park_factory_basic(self):
|
|
"""Test basic park factory functionality."""
|
|
park = ParkFactory.build()
|
|
self.assertTrue(park.name.startswith("Test Park"))
|
|
self.assertEqual(park.status, "OPERATING")
|
|
self.assertIsNotNone(park.operator)
|
|
|
|
# Test that constraints are respected
|
|
self.assertGreaterEqual(park.average_rating, 1)
|
|
self.assertLessEqual(park.average_rating, 10)
|
|
self.assertGreaterEqual(park.ride_count, 0)
|
|
self.assertGreaterEqual(park.coaster_count, 0)
|
|
|
|
def test_park_factory_with_traits(self):
|
|
"""Test park factory with traits."""
|
|
# Closed park
|
|
closed_park = ParkFactory.build(**Traits.closed_park())
|
|
self.assertEqual(closed_park.status, "CLOSED_PERM")
|
|
self.assertIsNotNone(closed_park.closing_date)
|
|
|
|
# High rated park
|
|
high_rated = ParkFactory.build(**Traits.high_rated())
|
|
self.assertGreaterEqual(high_rated.average_rating, 8)
|
|
|
|
def test_ride_factory_basic(self):
|
|
"""Test basic ride factory functionality."""
|
|
ride = RideFactory.build()
|
|
self.assertTrue(ride.name.startswith("Test Ride"))
|
|
self.assertEqual(ride.status, "OPERATING")
|
|
self.assertIsNotNone(ride.park)
|
|
self.assertIsNotNone(ride.manufacturer)
|
|
|
|
# Test constraints
|
|
if ride.min_height_in and ride.max_height_in:
|
|
self.assertLessEqual(ride.min_height_in, ride.max_height_in)
|
|
self.assertGreaterEqual(ride.average_rating, 1)
|
|
self.assertLessEqual(ride.average_rating, 10)
|
|
|
|
def test_coaster_factory(self):
|
|
"""Test roller coaster specific factory."""
|
|
from .factories import CoasterFactory
|
|
|
|
coaster = CoasterFactory.build()
|
|
self.assertIn(coaster.category, ["RC", "WC"])
|
|
self.assertGreaterEqual(coaster.min_height_in, 42)
|
|
self.assertLessEqual(coaster.min_height_in, 54)
|
|
|
|
def test_review_factories(self):
|
|
"""Test review factory functionality."""
|
|
park_review = ParkReviewFactory.build()
|
|
self.assertGreaterEqual(park_review.rating, 1)
|
|
self.assertLessEqual(park_review.rating, 10)
|
|
self.assertTrue(park_review.is_published)
|
|
|
|
ride_review = RideReviewFactory.build()
|
|
self.assertGreaterEqual(ride_review.rating, 1)
|
|
self.assertLessEqual(ride_review.rating, 10)
|
|
|
|
def test_sequence_functionality(self):
|
|
"""Test that sequences work correctly."""
|
|
users = [UserFactory.build() for _ in range(3)]
|
|
usernames = [user.username for user in users]
|
|
|
|
# Should have unique usernames
|
|
self.assertEqual(len(set(usernames)), 3)
|
|
self.assertTrue(all("testuser" in username for username in usernames))
|
|
|
|
def test_lazy_attributes(self):
|
|
"""Test lazy attribute functionality."""
|
|
park = ParkFactory.build(name="Custom Park Name")
|
|
self.assertEqual(park.slug, "custom-park-name")
|
|
|
|
def test_fuzzy_fields(self):
|
|
"""Test fuzzy field generation."""
|
|
parks = [ParkFactory.build() for _ in range(10)]
|
|
|
|
# Should have varied values
|
|
ratings = [p.average_rating for p in parks if p.average_rating]
|
|
# Should have different ratings
|
|
self.assertGreater(len(set(ratings)), 1)
|
|
|
|
ride_counts = [p.ride_count for p in parks if p.ride_count]
|
|
# Should have different counts
|
|
self.assertGreater(len(set(ride_counts)), 1)
|
|
|
|
|
|
class TestScenariosTestCase(TestCase):
|
|
"""Test case for pre-configured test scenarios."""
|
|
|
|
def test_build_only_scenario(self):
|
|
"""Test scenarios using build() to avoid database operations."""
|
|
# Create minimal scenario data using build()
|
|
park = ParkFactory.build()
|
|
rides = [RideFactory.build(park=park) for _ in range(3)]
|
|
|
|
# Verify the scenario
|
|
self.assertEqual(len(rides), 3)
|
|
for ride in rides:
|
|
self.assertEqual(ride.park, park)
|
|
|
|
def test_review_scenario_build(self):
|
|
"""Test review scenario using build()."""
|
|
park = ParkFactory.build()
|
|
users = [UserFactory.build() for _ in range(3)]
|
|
reviews = [ParkReviewFactory.build(park=park, user=user) for user in users]
|
|
|
|
# Verify scenario
|
|
self.assertEqual(len(reviews), 3)
|
|
for review in reviews:
|
|
self.assertEqual(review.park, park)
|
|
self.assertIn(review.user, users)
|
|
|
|
|
|
class FactoryValidationTestCase(TestCase):
|
|
"""Test that factories respect model validation."""
|
|
|
|
def test_rating_constraints(self):
|
|
"""Test that rating constraints are respected."""
|
|
# Valid ratings
|
|
valid_review = ParkReviewFactory.build(rating=5)
|
|
self.assertEqual(valid_review.rating, 5)
|
|
|
|
# Edge cases
|
|
min_review = ParkReviewFactory.build(rating=1)
|
|
self.assertEqual(min_review.rating, 1)
|
|
|
|
max_review = ParkReviewFactory.build(rating=10)
|
|
self.assertEqual(max_review.rating, 10)
|
|
|
|
def test_date_constraints(self):
|
|
"""Test that date constraints are logical."""
|
|
from datetime import date
|
|
|
|
# Valid dates
|
|
park = ParkFactory.build(
|
|
opening_date=date(2020, 1, 1), closing_date=date(2023, 12, 31)
|
|
)
|
|
|
|
# Verify opening is before closing
|
|
if park.opening_date and park.closing_date:
|
|
self.assertLessEqual(park.opening_date, park.closing_date)
|
|
|
|
def test_height_requirements(self):
|
|
"""Test that height requirements are logical."""
|
|
ride = RideFactory.build(min_height_in=48, max_height_in=72)
|
|
|
|
if ride.min_height_in and ride.max_height_in:
|
|
self.assertLessEqual(ride.min_height_in, ride.max_height_in)
|
|
|
|
|
|
class FactoryPerformanceTestCase(TestCase):
|
|
"""Test factory performance and bulk operations."""
|
|
|
|
def test_bulk_creation_build(self):
|
|
"""Test bulk creation using build() for performance."""
|
|
import time
|
|
|
|
start_time = time.time()
|
|
users = [UserFactory.build() for _ in range(100)]
|
|
build_time = time.time() - start_time
|
|
|
|
self.assertEqual(len(users), 100)
|
|
self.assertLess(build_time, 1.0) # Should be fast with build()
|
|
|
|
# Verify uniqueness
|
|
usernames = [user.username for user in users]
|
|
self.assertEqual(len(set(usernames)), 100)
|
|
|
|
def test_related_object_creation(self):
|
|
"""Test creation of objects with relationships."""
|
|
# Build park with relationships
|
|
park = ParkFactory.build()
|
|
|
|
# Verify relationships exist
|
|
self.assertIsNotNone(park.operator)
|
|
self.assertIsNotNone(park.property_owner)
|
|
|
|
# Build ride with park relationship
|
|
ride = RideFactory.build(park=park)
|
|
self.assertEqual(ride.park, park)
|