Revert "update"

This reverts commit 75cc618c2b.

backend/apps/parks/tests_disabled/README.md

@@ -0,0 +1,127 @@
+# Park Search Tests
+
+## Overview
+
+Test suite for the park search functionality including:
+- Autocomplete widget integration
+- Search form validation
+- Filter integration
+- HTMX interaction
+- View mode persistence
+
+## Running Tests
+
+```bash
+# Run all park tests
+uv run pytest parks/tests/
+
+# Run specific search tests
+uv run pytest parks/tests/test_search.py
+
+# Run with coverage
+uv run pytest --cov=parks parks/tests/
+```
+
+## Test Coverage
+
+### Search API Tests
+- `test_search_json_format`: Validates API response structure
+- `test_empty_search_json`: Tests empty search handling
+- `test_search_format_validation`: Verifies all required fields and types
+- `test_suggestion_limit`: Confirms 8-item result limit
+
+### Search Functionality Tests
+- `test_autocomplete_results`: Validates real-time suggestion filtering
+- `test_search_with_filters`: Tests filter integration with search
+- `test_partial_match_search`: Verifies partial text matching works
+
+### UI Integration Tests
+- `test_view_mode_persistence`: Ensures view mode is maintained
+- `test_empty_search`: Tests default state behavior
+- `test_htmx_request_handling`: Validates HTMX interactions
+
+### Data Format Tests
+- Field types validation
+- Location formatting
+- Status display formatting
+- URL generation
+- Response structure
+
+### Frontend Integration
+- HTMX partial updates
+- Alpine.js state management
+- Loading indicators
+- View mode persistence
+- Keyboard navigation
+
+### Test Commands
+```bash
+# Run all park tests
+uv run pytest parks/tests/
+
+# Run search tests specifically
+uv run pytest parks/tests/test_search.py
+
+# Run with coverage
+uv run pytest --cov=parks parks/tests/
+```
+
+### Coverage Areas
+1. Search Functionality:
+   - Suggestion generation
+   - Result filtering
+   - Partial matching
+   - Empty state handling
+
+2. UI Integration:
+   - HTMX requests
+   - View mode switching
+   - Loading states
+   - Error handling
+
+3. Performance:
+   - Result limiting
+   - Debouncing
+   - Query optimization
+
+4. Accessibility:
+   - ARIA attributes
+   - Keyboard controls
+   - Screen reader support
+
+## Configuration
+
+Tests use pytest-django and require:
+- PostgreSQL database
+- HTMX middleware
+- Autocomplete app configuration
+
+## Fixtures
+
+The test suite uses standard Django test fixtures. No additional fixtures required.
+
+## Common Issues
+
+1. Database Errors
+   - Ensure PostGIS extensions are installed
+   - Verify database permissions
+
+2. HTMX Tests
+   - Use `HTTP_HX_REQUEST` header for HTMX requests
+   - Check response content for HTMX attributes
+
+## Adding New Tests
+
+When adding tests, ensure:
+1. Database isolation using `@pytest.mark.django_db`
+2. Proper test naming following `test_*` convention
+3. Clear test descriptions in docstrings
+4. Coverage for both success and failure cases
+5. HTMX interaction testing where applicable
+
+## Future Improvements
+
+- Add performance benchmarks
+- Include accessibility tests
+- Add Playwright e2e tests
+- Implement geographic search tests

backend/apps/parks/tests_disabled/__init__.py

@@ -0,0 +1 @@
+# Parks app test suite

backend/apps/parks/tests_disabled/test_filters.py

@@ -0,0 +1,223 @@
+"""
+Tests for park filtering functionality including search, status filtering,
+date ranges, and numeric validations.
+"""
+
+from django.test import TestCase
+from datetime import date
+
+from apps.parks.models import Park, ParkLocation, Company
+from apps.parks.filters import ParkFilter
+
+# NOTE: These tests need to be updated to work with the new ParkLocation model
+# instead of the generic Location model
+
+
+class ParkFilterTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        """Set up test data for all filter tests"""
+        # Create operators
+        cls.operator1 = Company.objects.create(
+            name="Thrilling Adventures Inc", slug="thrilling-adventures"
+        )
+        cls.operator2 = Company.objects.create(
+            name="Family Fun Corp", slug="family-fun"
+        )
+
+        # Create parks with various attributes for testing all filters
+        cls.park1 = Park.objects.create(
+            name="Thrilling Adventures Park",
+            description="A thrilling park with lots of roller coasters",
+            status="OPERATING",
+            operator=cls.operator1,
+            opening_date=date(2020, 1, 1),
+            size_acres=100,
+            ride_count=20,
+            coaster_count=5,
+            average_rating=4.5,
+        )
+        ParkLocation.objects.create(
+            park=cls.park1,
+            street_address="123 Thrill St",
+            city="Thrill City",
+            state="Thrill State",
+            country="USA",
+            postal_code="12345",
+        )
+
+        cls.park2 = Park.objects.create(
+            name="Family Fun Park",
+            description="Family-friendly entertainment and attractions",
+            status="CLOSED_TEMP",
+            operator=cls.operator2,
+            opening_date=date(2015, 6, 15),
+            size_acres=50,
+            ride_count=15,
+            coaster_count=2,
+            average_rating=4.0,
+        )
+        ParkLocation.objects.create(
+            park=cls.park2,
+            street_address="456 Fun St",
+            city="Fun City",
+            state="Fun State",
+            country="Canada",
+            postal_code="54321",
+        )
+
+        # Park with minimal data for edge case testing
+        cls.park3 = Park.objects.create(
+            name="Incomplete Park",
+            status="UNDER_CONSTRUCTION",
+            operator=cls.operator1,
+        )
+
+    def test_text_search(self):
+        """Test search functionality across different fields"""
+        # Test name search
+        queryset = ParkFilter(data={"search": "Thrilling"}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park1, queryset)
+
+        # Test description search
+        queryset = ParkFilter(data={"search": "family-friendly"}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park2, queryset)
+
+        # Test location search
+        queryset = ParkFilter(data={"search": "Thrill City"}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park1, queryset)
+
+        # Test combined field search
+        queryset = ParkFilter(data={"search": "Park"}).qs
+        self.assertEqual(queryset.count(), 3)
+
+        # Test empty search
+        queryset = ParkFilter(data={}).qs
+        self.assertEqual(queryset.count(), 3)
+
+    def test_status_filtering(self):
+        """Test status filter with various values"""
+        # Test each status
+        status_tests = {
+            "OPERATING": [self.park1],
+            "CLOSED_TEMP": [self.park2],
+            "UNDER_CONSTRUCTION": [self.park3],
+        }
+
+        for status, expected_parks in status_tests.items():
+            queryset = ParkFilter(data={"status": status}).qs
+            self.assertEqual(queryset.count(), len(expected_parks))
+            for park in expected_parks:
+                self.assertIn(park, queryset)
+
+        # Test empty status (should return all)
+        queryset = ParkFilter(data={}).qs
+        self.assertEqual(queryset.count(), 3)
+
+        # Test empty string status (should return all)
+        queryset = ParkFilter(data={"status": ""}).qs
+        self.assertEqual(queryset.count(), 3)
+
+        # Test invalid status (should return no results)
+        queryset = ParkFilter(data={"status": "INVALID"}).qs
+        self.assertEqual(queryset.count(), 0)
+
+    def test_date_range_filtering(self):
+        """Test date range filter functionality"""
+        # Test various date range scenarios
+        test_cases = [
+            # Start date only
+            ({"opening_date_after": "2019-01-01"}, [self.park1]),
+            # End date only
+            ({"opening_date_before": "2016-01-01"}, [self.park2]),
+            # Date range including one park
+            (
+                {
+                    "opening_date_after": "2014-01-01",
+                    "opening_date_before": "2016-01-01",
+                },
+                [self.park2],
+            ),
+            # Date range including multiple parks
+            (
+                {
+                    "opening_date_after": "2014-01-01",
+                    "opening_date_before": "2022-01-01",
+                },
+                [self.park1, self.park2],
+            ),
+            # Empty filter (should return all)
+            ({}, [self.park1, self.park2, self.park3]),
+            # Future date (should return none)
+            ({"opening_date_after": "2030-01-01"}, []),
+        ]
+
+        for filter_data, expected_parks in test_cases:
+            queryset = ParkFilter(data=filter_data).qs
+            self.assertEqual(
+                set(queryset),
+                set(expected_parks),
+                f"Failed for filter: {filter_data}",
+            )
+
+        # Test invalid date formats
+        invalid_dates = [
+            {"opening_date_after": "invalid-date"},
+            {"opening_date_before": "2023-13-01"},  # Invalid month
+            {"opening_date_after": "2023-01-32"},  # Invalid day
+            {"opening_date_before": "not-a-date"},
+        ]
+
+        for invalid_data in invalid_dates:
+            filter_instance = ParkFilter(data=invalid_data)
+            self.assertFalse(
+                filter_instance.is_valid(),
+                f"Filter should be invalid for data: {invalid_data}",
+            )
+
+    def test_numeric_filtering(self):
+        """Test numeric filters with validation"""
+        # Test minimum rides filter
+        test_cases = [
+            ({"min_rides": "18"}, [self.park1]),  # Only park1 has >= 18 rides
+            (
+                {"min_rides": "10"},
+                [self.park1, self.park2],
+            ),  # Both park1 and park2 have >= 10 rides
+            (
+                {"min_rides": "0"},
+                [self.park1, self.park2, self.park3],
+            ),  # All parks have >= 0 rides
+            # No filter should return all
+            ({}, [self.park1, self.park2, self.park3]),
+        ]
+
+        for filter_data, expected_parks in test_cases:
+            queryset = ParkFilter(data=filter_data).qs
+            self.assertEqual(
+                set(queryset),
+                set(expected_parks),
+                f"Failed for filter: {filter_data}",
+            )
+
+        # Test coaster count filter
+        queryset = ParkFilter(data={"min_coasters": "3"}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park1, queryset)
+
+        # Test size filter
+        queryset = ParkFilter(data={"min_size": "75"}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park1, queryset)
+
+        # Test validation
+        invalid_values = ["-1", "invalid", "0.5"]
+        for value in invalid_values:
+            filter_instance = ParkFilter(data={"min_rides": value})
+            self.assertFalse(
+                filter_instance.is_valid(),
+                f"Filter should be invalid for value: {value}",
+            )

backend/apps/parks/tests_disabled/test_models.py

@@ -0,0 +1,175 @@
+"""
+Tests for park models functionality including CRUD operations,
+slug handling, status management, and location integration.
+"""
+
+from django.test import TestCase
+from django.db import IntegrityError
+
+from apps.parks.models import Park, ParkArea, ParkLocation, Company
+
+# NOTE: These tests need to be updated to work with the new ParkLocation model
+# instead of the generic Location model
+
+
+class ParkModelTests(TestCase):
+    def setUp(self):
+        """Set up test data"""
+        self.operator = Company.objects.create(name="Test Company", slug="test-company")
+
+        # Create a basic park
+        self.park = Park.objects.create(
+            name="Test Park",
+            description="A test park",
+            status="OPERATING",
+            operator=self.operator,
+        )
+
+        # Create location for the park
+        self.location = ParkLocation.objects.create(
+            park=self.park,
+            street_address="123 Test St",
+            city="Test City",
+            state="Test State",
+            country="Test Country",
+            postal_code="12345",
+        )
+        self.location.set_coordinates(40.7128, -74.0060)
+        self.location.save()
+
+    def test_park_creation(self):
+        """Test basic park creation and fields"""
+        self.assertEqual(self.park.name, "Test Park")
+        self.assertEqual(self.park.slug, "test-park")
+        self.assertEqual(self.park.status, "OPERATING")
+        self.assertEqual(self.park.operator, self.operator)
+
+    def test_slug_generation(self):
+        """Test automatic slug generation"""
+        park = Park.objects.create(
+            name="Another Test Park",
+            status="OPERATING",
+            operator=self.operator,
+        )
+        self.assertEqual(park.slug, "another-test-park")
+
+    def test_historical_slug_lookup(self):
+        """Test finding park by historical slug"""
+        from django.db import transaction
+        from django.contrib.contenttypes.models import ContentType
+        from core.history import HistoricalSlug
+
+        with transaction.atomic():
+            # Create initial park with a specific name/slug
+            park = Park.objects.create(
+                name="Original Park Name",
+                description="Test description",
+                status="OPERATING",
+                operator=self.operator,
+            )
+            original_slug = park.slug
+            print(f"\nInitial park created with slug: {original_slug}")
+
+            # Ensure we have a save to trigger history
+            park.save()
+
+            # Modify name to trigger slug change
+            park.name = "Updated Park Name"
+            park.save()
+            new_slug = park.slug
+            print(f"Park updated with new slug: {new_slug}")
+
+            # Check HistoricalSlug records
+            historical_slugs = HistoricalSlug.objects.filter(
+                content_type=ContentType.objects.get_for_model(Park),
+                object_id=park.id,
+            )
+            print(f"Historical slug records: {[h.slug for h in historical_slugs]}")
+
+            # Check pghistory records
+            event_model = getattr(Park, "event_model", None)
+            if event_model:
+                historical_records = event_model.objects.filter(
+                    pgh_obj_id=park.id
+                ).order_by("-pgh_created_at")
+                print("\nPG History records:")
+                for record in historical_records:
+                    print(f"- Event ID: {record.pgh_id}")
+                    print(f"  Name: {record.name}")
+                    print(f"  Slug: {record.slug}")
+                    print(f"  Created At: {record.pgh_created_at}")
+            else:
+                print("\nNo pghistory event model available")
+
+            # Try to find by old slug
+            found_park, is_historical = Park.get_by_slug(original_slug)
+            self.assertEqual(found_park.id, park.id)
+            print(
+                f"Found park by old slug: {found_park.slug}, is_historical: {is_historical}"
+            )
+            self.assertTrue(is_historical)
+
+            # Try current slug
+            found_park, is_historical = Park.get_by_slug(new_slug)
+            self.assertEqual(found_park.id, park.id)
+            print(
+                f"Found park by new slug: {found_park.slug}, is_historical: {is_historical}"
+            )
+            self.assertFalse(is_historical)
+
+    def test_status_color_mapping(self):
+        """Test status color class mapping"""
+        status_tests = {
+            "OPERATING": "bg-green-100 text-green-800",
+            "CLOSED_TEMP": "bg-yellow-100 text-yellow-800",
+            "CLOSED_PERM": "bg-red-100 text-red-800",
+            "UNDER_CONSTRUCTION": "bg-blue-100 text-blue-800",
+            "DEMOLISHED": "bg-gray-100 text-gray-800",
+            "RELOCATED": "bg-purple-100 text-purple-800",
+        }
+
+        for status, expected_color in status_tests.items():
+            self.park.status = status
+            self.assertEqual(self.park.get_status_color(), expected_color)
+
+    def test_absolute_url(self):
+        """Test get_absolute_url method"""
+        expected_url = f"/parks/{self.park.slug}/"
+        self.assertEqual(self.park.get_absolute_url(), expected_url)
+
+
+class ParkAreaModelTests(TestCase):
+    def setUp(self):
+        """Set up test data"""
+        self.operator = Company.objects.create(
+            name="Test Company 2", slug="test-company-2"
+        )
+        self.park = Park.objects.create(
+            name="Test Park", status="OPERATING", operator=self.operator
+        )
+        self.area = ParkArea.objects.create(
+            park=self.park, name="Test Area", description="A test area"
+        )
+
+    def test_area_creation(self):
+        """Test basic area creation and fields"""
+        self.assertEqual(self.area.name, "Test Area")
+        self.assertEqual(self.area.slug, "test-area")
+        self.assertEqual(self.area.park, self.park)
+
+    def test_unique_together_constraint(self):
+        """Test unique_together constraint for park and slug"""
+        from django.db import transaction
+
+        # Try to create area with same slug in same park
+        with transaction.atomic():
+            with self.assertRaises(IntegrityError):
+                ParkArea.objects.create(
+                    park=self.park,
+                    name="Test Area",  # Will generate same slug
+                )
+
+        # Should be able to use same name in different park
+        other_park = Park.objects.create(name="Other Park", operator=self.operator)
+        area = ParkArea.objects.create(park=other_park, name="Test Area")
+        self.assertEqual(area.slug, "test-area")

backend/apps/parks/tests_disabled/test_search.py

@@ -0,0 +1,173 @@
+import pytest
+from django.urls import reverse
+from django.test import Client
+
+from apps.parks.models import Park
+from apps.parks.forms import ParkAutocomplete, ParkSearchForm
+
+
+@pytest.mark.django_db
+class TestParkSearch:
+    def test_autocomplete_results(self, client: Client):
+        """Test that autocomplete returns correct results"""
+        # Create test parks
+        park1 = Park.objects.create(name="Test Park")
+        park2 = Park.objects.create(name="Another Park")
+        park3 = Park.objects.create(name="Test Garden")
+
+        # Get autocomplete results
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Test"})
+
+        # Check response
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert park1.name in content
+        assert park3.name in content
+        assert park2.name not in content
+
+    def test_search_form_valid(self):
+        """Test ParkSearchForm validation"""
+        form = ParkSearchForm(data={})
+        assert form.is_valid()
+
+    def test_autocomplete_class(self):
+        """Test ParkAutocomplete configuration"""
+        ac = ParkAutocomplete()
+        assert ac.model == Park
+        assert "name" in ac.search_attrs
+
+    def test_search_with_filters(self, client: Client):
+        """Test search works with filters"""
+        park = Park.objects.create(name="Test Park", status="OPERATING")
+
+        # Search with status filter
+        url = reverse("parks:park_list")
+        response = client.get(url, {"park": str(park.pk), "status": "OPERATING"})
+
+        assert response.status_code == 200
+        assert park.name in response.content.decode()
+
+    def test_empty_search(self, client: Client):
+        """Test empty search returns all parks"""
+        Park.objects.create(name="Test Park")
+        Park.objects.create(name="Another Park")
+
+        url = reverse("parks:park_list")
+        response = client.get(url)
+
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "Test Park" in content
+        assert "Another Park" in content
+
+    def test_partial_match_search(self, client: Client):
+        """Test partial matching in search"""
+        Park.objects.create(name="Adventure World")
+        Park.objects.create(name="Water Adventure")
+
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Adv"})
+
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "Adventure World" in content
+        assert "Water Adventure" in content
+
+    def test_htmx_request_handling(self, client: Client):
+        """Test HTMX-specific request handling"""
+        Park.objects.create(name="Test Park")
+
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Test"}, HTTP_HX_REQUEST="true")
+
+        assert response.status_code == 200
+        assert "Test Park" in response.content.decode()
+
+    def test_view_mode_persistence(self, client: Client):
+        """Test view mode is maintained during search"""
+        Park.objects.create(name="Test Park")
+
+        url = reverse("parks:park_list")
+        response = client.get(url, {"park": "Test", "view_mode": "list"})
+
+        assert response.status_code == 200
+        assert 'data-view-mode="list"' in response.content.decode()
+
+    def test_suggestion_limit(self, client: Client):
+        """Test that suggestions are limited to 8 items"""
+        # Create 10 parks
+        for i in range(10):
+            Park.objects.create(name=f"Test Park {i}")
+
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Test"})
+
+        content = response.content.decode()
+        result_count = content.count("Test Park")
+        assert result_count == 8  # Verify limit is enforced
+
+    def test_search_json_format(self, client: Client):
+        """Test that search returns properly formatted JSON"""
+        park = Park.objects.create(
+            name="Test Park",
+            status="OPERATING",
+            city="Test City",
+            state="Test State",
+        )
+
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Test"})
+
+        assert response.status_code == 200
+        data = response.json()
+        assert "results" in data
+        assert len(data["results"]) == 1
+
+        result = data["results"][0]
+        assert result["id"] == str(park.pk)
+        assert result["name"] == "Test Park"
+        assert result["status"] == "Operating"
+        assert result["location"] == park.formatted_location
+        assert result["url"] == reverse("parks:park_detail", kwargs={"slug": park.slug})
+
+    def test_empty_search_json(self, client: Client):
+        """Test empty search returns empty results array"""
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": ""})
+
+        assert response.status_code == 200
+        data = response.json()
+        assert "results" in data
+        assert len(data["results"]) == 0
+
+    def test_search_format_validation(self, client: Client):
+        """Test that all fields are properly formatted in search results"""
+        Park.objects.create(
+            name="Test Park",
+            status="OPERATING",
+            city="Test City",
+            state="Test State",
+            country="Test Country",
+        )
+
+        expected_fields = {"id", "name", "status", "location", "url"}
+
+        url = reverse("parks:suggest_parks")
+        response = client.get(url, {"search": "Test"})
+        data = response.json()
+        result = data["results"][0]
+
+        # Check all expected fields are present
+        assert set(result.keys()) == expected_fields
+
+        # Check field types
+        assert isinstance(result["id"], str)
+        assert isinstance(result["name"], str)
+        assert isinstance(result["status"], str)
+        assert isinstance(result["location"], str)
+        assert isinstance(result["url"], str)
+
+        # Check formatted location includes city and state
+        assert "Test City" in result["location"]
+        assert "Test State" in result["location"]