Revert "update"

This reverts commit 75cc618c2b.

backend/tests/test_factories.py

@@ -0,0 +1,244 @@
+"""
+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)