series of tests added with built-in django test support

parks/migrations/0009_migrate_to_location_model.py

@@ -10,8 +10,8 @@ def forwards_func(apps, schema_editor):
     ContentType = apps.get_model("contenttypes", "ContentType")
     db_alias = schema_editor.connection.alias
 
-    # Get content type for Park model
-    park_content_type = ContentType.objects.db_manager(db_alias).get(
+    # Get or create content type for Park model
+    park_content_type, created = ContentType.objects.db_manager(db_alias).get_or_create(
         app_label='parks',
         model='park'
     )
@@ -42,8 +42,8 @@ def reverse_func(apps, schema_editor):
     ContentType = apps.get_model("contenttypes", "ContentType")
     db_alias = schema_editor.connection.alias
 
-    # Get content type for Park model
-    park_content_type = ContentType.objects.db_manager(db_alias).get(
+    # Get or create content type for Park model
+    park_content_type, created = ContentType.objects.db_manager(db_alias).get_or_create(
         app_label='parks',
         model='park'
     )

parks/templatetags/park_tags.py

@@ -0,0 +1,10 @@
+from django import template
+
+register = template.Library()
+
+@register.filter
+def has_reviewed_park(user, park):
+    """Check if a user has reviewed a park"""
+    if not user.is_authenticated:
+        return False
+    return park.reviews.filter(user=user).exists()

parks/tests.py

@@ -1,3 +1,194 @@
-from django.test import TestCase
+from django.test import TestCase, Client
+from django.urls import reverse
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.gis.geos import Point
+from .models import Park, ParkArea
+from companies.models import Company
+from location.models import Location
 
-# Create your tests here.
+User = get_user_model()
+
+class ParkModelTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        # Create test user
+        cls.user = User.objects.create_user(
+            username='testuser',
+            email='test@example.com',
+            password='testpass123'
+        )
+        
+        # Create test company
+        cls.company = Company.objects.create(
+            name='Test Company',
+            website='http://example.com'
+        )
+        
+        # Create test park
+        cls.park = Park.objects.create(
+            name='Test Park',
+            owner=cls.company,
+            status='OPERATING',
+            website='http://testpark.com'
+        )
+        
+        # Create test location
+        cls.location = Location.objects.create(
+            content_type=ContentType.objects.get_for_model(Park),
+            object_id=cls.park.id,
+            name='Test Park Location',
+            location_type='park',
+            street_address='123 Test St',
+            city='Test City',
+            state='TS',
+            country='Test Country',
+            postal_code='12345',
+            point=Point(-118.2437, 34.0522)  # Los Angeles coordinates
+        )
+
+    def test_park_creation(self):
+        """Test park instance creation and field values"""
+        self.assertEqual(self.park.name, 'Test Park')
+        self.assertEqual(self.park.owner, self.company)
+        self.assertEqual(self.park.status, 'OPERATING')
+        self.assertEqual(self.park.website, 'http://testpark.com')
+        self.assertTrue(self.park.slug)
+
+    def test_park_str_representation(self):
+        """Test string representation of park"""
+        self.assertEqual(str(self.park), 'Test Park')
+
+    def test_park_location(self):
+        """Test park location relationship"""
+        self.assertTrue(self.park.location.exists())
+        location = self.park.location.first()
+        self.assertEqual(location.street_address, '123 Test St')
+        self.assertEqual(location.city, 'Test City')
+        self.assertEqual(location.state, 'TS')
+        self.assertEqual(location.country, 'Test Country')
+        self.assertEqual(location.postal_code, '12345')
+
+    def test_park_coordinates(self):
+        """Test park coordinates property"""
+        coords = self.park.coordinates
+        self.assertIsNotNone(coords)
+        self.assertAlmostEqual(coords[0], 34.0522, places=4)  # latitude
+        self.assertAlmostEqual(coords[1], -118.2437, places=4)  # longitude
+
+    def test_park_formatted_location(self):
+        """Test park formatted_location property"""
+        expected = '123 Test St, Test City, TS, 12345, Test Country'
+        self.assertEqual(self.park.formatted_location, expected)
+
+class ParkAreaTests(TestCase):
+    def setUp(self):
+        # Create test company
+        self.company = Company.objects.create(
+            name='Test Company',
+            website='http://example.com'
+        )
+        
+        # Create test park
+        self.park = Park.objects.create(
+            name='Test Park',
+            owner=self.company,
+            status='OPERATING'
+        )
+        
+        # Create test location
+        self.location = Location.objects.create(
+            content_type=ContentType.objects.get_for_model(Park),
+            object_id=self.park.id,
+            name='Test Park Location',
+            location_type='park',
+            street_address='123 Test St',  # Added street_address
+            city='Test City',
+            state='TS',
+            country='Test Country',
+            postal_code='12345',
+            point=Point(-118.2437, 34.0522)
+        )
+        
+        # Create test area
+        self.area = ParkArea.objects.create(
+            park=self.park,
+            name='Test Area',
+            description='Test Description'
+        )
+
+    def test_area_creation(self):
+        """Test park area creation"""
+        self.assertEqual(self.area.name, 'Test Area')
+        self.assertEqual(self.area.park, self.park)
+        self.assertTrue(self.area.slug)
+
+    def test_area_str_representation(self):
+        """Test string representation of park area"""
+        expected = f'Test Area at {self.park.name}'
+        self.assertEqual(str(self.area), expected)
+
+    def test_area_get_by_slug(self):
+        """Test get_by_slug class method"""
+        area, is_historical = ParkArea.get_by_slug(self.area.slug)
+        self.assertEqual(area, self.area)
+        self.assertFalse(is_historical)
+
+class ParkViewTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.user = User.objects.create_user(
+            username='testuser',
+            email='test@example.com',
+            password='testpass123'
+        )
+        self.company = Company.objects.create(
+            name='Test Company',
+            website='http://example.com'
+        )
+        self.park = Park.objects.create(
+            name='Test Park',
+            owner=self.company,
+            status='OPERATING'
+        )
+        self.location = Location.objects.create(
+            content_type=ContentType.objects.get_for_model(Park),
+            object_id=self.park.id,
+            name='Test Park Location',
+            location_type='park',
+            street_address='123 Test St',  # Added street_address
+            city='Test City',
+            state='TS',
+            country='Test Country',
+            postal_code='12345',
+            point=Point(-118.2437, 34.0522)
+        )
+
+    def test_park_list_view(self):
+        """Test park list view"""
+        response = self.client.get(reverse('parks:park_list'))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.park.name)
+
+    def test_park_detail_view(self):
+        """Test park detail view"""
+        response = self.client.get(
+            reverse('parks:park_detail', kwargs={'slug': self.park.slug})
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.park.name)
+        self.assertContains(response, '123 Test St')
+
+    def test_park_area_detail_view(self):
+        """Test park area detail view"""
+        area = ParkArea.objects.create(
+            park=self.park,
+            name='Test Area'
+        )
+        response = self.client.get(
+            reverse('parks:area_detail', 
+                   kwargs={'park_slug': self.park.slug, 'area_slug': area.slug})
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, area.name)