major changes, including tailwind v4

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

parks/tests_disabled/__init__.py

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

parks/tests_disabled/test_filters.py

@@ -0,0 +1,260 @@
+"""
+Tests for park filtering functionality including search, status filtering,
+date ranges, and numeric validations.
+"""
+from django.test import TestCase
+from django.contrib.contenttypes.models import ContentType
+from django.utils import timezone
+from datetime import date, timedelta
+
+from parks.models import Park, ParkLocation
+from parks.filters import ParkFilter
+from parks.models.companies import Operator
+# 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 = Operator.objects.create(
+            name="Thrilling Adventures Inc",
+            slug="thrilling-adventures"
+        )
+        cls.operator2 = Operator.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
+        )
+        Location.objects.create(
+            name="Thrilling Adventures Location",
+            location_type="park",
+            street_address="123 Thrill St",
+            city="Thrill City",
+            state="Thrill State",
+            country="USA",
+            postal_code="12345",
+            latitude=40.7128,
+            longitude=-74.0060,
+            content_object=cls.park1
+        )
+        
+        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
+        )
+        Location.objects.create(
+            name="Family Fun Location",
+            location_type="park",
+            street_address="456 Fun St",
+            city="Fun City",
+            state="Fun State",
+            country="Canada",
+            postal_code="54321",
+            latitude=43.6532,
+            longitude=-79.3832,
+            content_object=cls.park2
+        )
+        
+        # Park with minimal data for edge case testing
+        cls.park3 = Park.objects.create(
+            name="Incomplete Park",
+            status="UNDER_CONSTRUCTION"
+        )
+    
+    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_operator_filtering(self):
+        """Test operator filtering"""
+        # Test specific operator
+        queryset = ParkFilter(data={"operator": str(self.operator1.pk)}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park1, queryset)
+        
+        # Test other operator
+        queryset = ParkFilter(data={"operator": str(self.operator2.pk)}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park2, queryset)
+        
+        # Test parks without operator
+        queryset = ParkFilter(data={"has_operator": False}).qs
+        self.assertEqual(queryset.count(), 1)
+        self.assertIn(self.park3, queryset)
+        
+        # Test parks with any operator
+        queryset = ParkFilter(data={"has_operator": True}).qs
+        self.assertEqual(queryset.count(), 2)
+        self.assertIn(self.park1, queryset)
+        self.assertIn(self.park2, queryset)
+        
+        # Test empty filter (should return all)
+        queryset = ParkFilter(data={}).qs
+        self.assertEqual(queryset.count(), 3)
+        
+        # Test invalid operator ID
+        queryset = ParkFilter(data={"operator": "99999"}).qs
+        self.assertEqual(queryset.count(), 0)
+    
+    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
+            ({}, [self.park1, self.park2, self.park3]),  # No filter should return all
+        ]
+        
+        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}"
+            )

parks/tests_disabled/test_models.py

@@ -0,0 +1,218 @@
+"""
+Tests for park models functionality including CRUD operations,
+slug handling, status management, and location integration.
+"""
+from django.test import TestCase
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError
+from django.utils import timezone
+from datetime import date
+
+from parks.models import Park, ParkArea, ParkLocation
+from parks.models.companies import Operator
+# 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 = Operator.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 = Location.objects.create(
+            name="Test Park Location",
+            location_type="park",
+            street_address="123 Test St",
+            city="Test City",
+            state="Test State",
+            country="Test Country",
+            postal_code="12345",
+            latitude=40.7128,
+            longitude=-74.0060,
+            content_object=self.park
+        )
+
+    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"
+        )
+        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"
+            )
+            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(f"\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_location_integration(self):
+        """Test location-related functionality"""
+        # Test formatted location - compare individual components
+        location = self.park.location.first()
+        self.assertIsNotNone(location)
+        formatted_address = location.get_formatted_address()
+        self.assertIn("123 Test St", formatted_address)
+        self.assertIn("Test City", formatted_address)
+        self.assertIn("Test State", formatted_address)
+        self.assertIn("12345", formatted_address)
+        self.assertIn("Test Country", formatted_address)
+        
+        # Test coordinates
+        self.assertEqual(self.park.coordinates, (40.7128, -74.0060))
+        
+        # Test park without location
+        park = Park.objects.create(name="No Location Park")
+        self.assertEqual(park.formatted_location, "")
+        self.assertIsNone(park.coordinates)
+
+    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.park = Park.objects.create(
+            name="Test Park",
+            status="OPERATING"
+        )
+        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_historical_slug_lookup(self):
+        """Test finding area by historical slug"""
+        # Change area name/slug
+        self.area.name = "Updated Area Name"
+        self.area.save()
+        
+        # Try to find by old slug
+        area, is_historical = ParkArea.get_by_slug("test-area")
+        self.assertEqual(area.id, self.area.id)
+        self.assertTrue(is_historical)
+        
+        # Try current slug
+        area, is_historical = ParkArea.get_by_slug("updated-area-name")
+        self.assertEqual(area.id, self.area.id)
+        self.assertFalse(is_historical)
+
+    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")
+        area = ParkArea.objects.create(
+            park=other_park,
+            name="Test Area"
+        )
+        self.assertEqual(area.slug, "test-area")
+
+    def test_absolute_url(self):
+        """Test get_absolute_url method"""
+        expected_url = f"/parks/{self.park.slug}/areas/{self.area.slug}/"
+        self.assertEqual(self.area.get_absolute_url(), expected_url)

parks/tests_disabled/test_search.py

@@ -0,0 +1,183 @@
+import pytest
+from django.urls import reverse
+from django.test import Client
+
+from parks.models import Park
+from 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 = 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']