gcivil-nyu-org / team4-wed-spring25 / 372

Committed 07 Apr 2025 11:16PM UTC coverage: 96.879% (+1.3%) from 95.573%

Build # 372

Build Type

push

travis-pro

Committed by

divya603

Commit Message

Fix flake8 issues: remove trailing whitespace in tests

Run Details

838 of 865 relevant lines covered (96.88%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.05

/parks/tests.py

from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth.models import User
from .models import DogRunNew, Review, ParkImage, ReviewReport, ImageReport
from django.core import mail


# import os
class UniqueEmailTests(TestCase):
    def setUp(self):
        self.client = Client()
        User.objects.create_user(
            username="existinguser",
            email="duplicate@pawpark.com",
            password="SomeStrongPassword1",
        )
        self.register_url = reverse("register")

    def test_duplicate_email_registration(self):
        """
        Attempting to register a new user with an email that already exists should
        re-render the form with an error message.
        """
        response = self.client.post(
            self.register_url,
            {
                "username": "newuser",
                "email": "duplicate@pawpark.com",
                "password1": "StrongPass123",
                "password2": "StrongPass123",
                "role": "user",
                "admin_access_code": "",
            },
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "A user with that email address already exists.")
        self.assertFalse(User.objects.filter(username="newuser").exists())


class WeakPasswordTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.register_url = reverse("register")

    def test_too_short_password(self):
        response = self.client.post(
            self.register_url,
            {
                "username": "weakuser",
                "password1": "123",
                "password2": "123",
                "role": "user",
            },
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(User.objects.filter(username="weakuser").exists())
        self.assertContains(response, "must contain at least 8 characters")

    def test_entirely_numeric_password(self):
        response = self.client.post(
            self.register_url,
            {
                "username": "numericuser",
                "password1": "12345678",
                "password2": "12345678",
                "role": "user",
            },
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(User.objects.filter(username="numericuser").exists())
        self.assertContains(response, "can’t be entirely numeric")


class PasswordResetTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            "resetuser", "reset@pawpark.com", "Pass123456"
        )

    def test_password_reset_page_loads(self):
        url = reverse("password_reset")
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "registration/password_reset_form.html")

    def test_password_reset_flow(self):
        """
        Ensure that posting an email to password_reset
        sends the user to password_reset_done,
        and optionally check that an email was
        "sent" (console backend or etc.)
        """
        url = reverse("password_reset")
        response = self.client.post(url, {"email": "reset@pawpark.com"})
        self.assertEqual(response.status_code, 302)
        self.assertRedirects(response, reverse("password_reset_done"))

        self.assertEqual(len(mail.outbox), 1)
        self.assertIn("resetuser", mail.outbox[0].body)


class AdminSignUpTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.register_url = reverse("register")

    def test_admin_signup_with_correct_code(self):
        """
        Signing up as admin with correct access code should create a staff user.
        """
        response = self.client.post(
            self.register_url,
            {
                "username": "adminuser",
                "password1": "StrongAdminPass123",
                "password2": "StrongAdminPass123",
                "role": "admin",
                "admin_access_code": "SUPERDOG123",
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(User.objects.filter(username="adminuser").exists())
        user = User.objects.get(username="adminuser")
        self.assertTrue(user.is_staff)

    def test_admin_signup_with_wrong_code(self):
        """
        Signing up as admin with wrong code should fail and not create staff user.
        """
        response = self.client.post(
            self.register_url,
            {
                "username": "fakeadmin",
                "password1": "StrongAdminPass123",
                "password2": "StrongAdminPass123",
                "role": "admin",
                "admin_access_code": "WRONGCODE",
            },
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(User.objects.filter(username="fakeadmin").exists())

    def test_signup_as_normal_user_ignores_access_code(self):
        """
        If someone chooses 'user' role, the admin_access_code is irrelevant.
        """
        response = self.client.post(
            self.register_url,
            {
                "username": "normaluser",
                "password1": "StrongPass456",
                "password2": "StrongPass456",
                "role": "user",
                "admin_access_code": "SUPERDOG123",
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(User.objects.filter(username="normaluser").exists())
        user = User.objects.get(username="normaluser")
        self.assertFalse(user.is_staff)


class LoginTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username="testuser", password="StrongPass123"
        )

    def test_login_page_loads(self):
        """Ensure the login page loads properly."""
        response = self.client.get(reverse("login"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "parks/login.html")

    def test_valid_login(self):
        """Ensure a valid user can log in."""
        response = self.client.post(
            reverse("login"), {"username": "testuser", "password": "StrongPass123"}
        )
        self.assertEqual(response.status_code, 302)


class AuthTests(TestCase):
    def setUp(self):
        self.client = Client()

    def test_register_page_loads(self):
        """Ensure the registration page loads properly."""
        response = self.client.get(reverse("register"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "parks/register.html")

    def test_user_registration(self):
        """Ensure a new user can register successfully."""
        response = self.client.post(
            reverse("register"),
            {
                "username": "testuser",
                "password1": "StrongPass123",
                "password2": "StrongPass123",
                "role": "user",  # Ensure this field is required
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(User.objects.filter(username="testuser").exists())


class ParkModelTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.park = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Test park notes",
            google_name="Central Park",
            borough="M",
            zip_code="United States",
            formatted_address="Central Pk N, New York, NY, USA",
            latitude=40.7987768,
            longitude=-73.9537196,
            additional={
                "geometry": {
                    "bounds": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                    "location": {"lat": 40.7987768, "lng": -73.9537196},
                    "location_type": "GEOMETRIC_CENTER",
                    "viewport": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                }
            },
        )

    def test_park_creation(self):
        self.assertEqual(self.park.name, "Central Park")
        self.assertEqual(self.park.address, "New York, NY")
        self.assertEqual(self.park.notes, "Test park notes")


class ReviewModelTest(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(username="testuser", password="123456abc")
        self.park = DogRunNew.objects.create(
            id="2",
            prop_id="5678",
            name="Brooklyn Park",
            address="Brooklyn, NY",
            dogruns_type="Large",
            accessible="No",
            notes="Another test park",
        )
        self.review = Review.objects.create(
            park=self.park, text="Great park!", rating=5, user=self.user
        )

    def test_review_creation(self):
        self.assertEqual(self.review.text, "Great park!")
        self.assertEqual(self.review.rating, 5)
        self.assertEqual(self.review.park.name, "Brooklyn Park")

    def test_review_str_method(self):
        self.assertEqual(str(self.review), "Review for Brooklyn Park (5 stars)")


class ParkListViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.park = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Test park notes",
            google_name="Central Park",
            borough="M",
            zip_code="United States",
            formatted_address="Central Pk N, New York, NY, USA",
            latitude=40.7987768,
            longitude=-73.9537196,
            additional={
                "geometry": {
                    "bounds": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                    "location": {"lat": 40.7987768, "lng": -73.9537196},
                    "location_type": "GEOMETRIC_CENTER",
                    "viewport": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                }
            },
        )

    def test_park_list_view(self):
        response = self.client.get(reverse("park_list"))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Central Park")


class MapViewTest(TestCase):
    def setUp(self):
        self.client = Client()

    def test_map_view(self):
        response = self.client.get(reverse("map"))
        self.assertEqual(response.status_code, 200)


class CombinedViewTest(TestCase):
    def test_combined_view(self):
        response = self.client.get(reverse("park_and_map"))
        self.assertEqual(response.status_code, 200)

    def setUp(self):
        self.client = Client()
        # One park in Manhattan
        self.park_manhattan = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Manhattan park",
            google_name="Central Park",
            borough="M",
            zip_code="10024",
            latitude=40.7987768,
            longitude=-73.9537196,
        )
        # One park in Brooklyn
        self.park_brooklyn = DogRunNew.objects.create(
            id="2",
            prop_id="5678",
            name="Brooklyn Bridge Park",
            address="Brooklyn, NY",
            dogruns_type="Large",
            accessible="Yes",
            notes="Brooklyn park",
            google_name="Brooklyn Bridge Park",
            borough="B",
            zip_code="11201",
            latitude=40.700292,
            longitude=-73.996123,
        )

    def test_combined_view_filters_by_borough(self):
        response = self.client.get(reverse("park_and_map"), {"borough": "M"})
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Central Park")
        self.assertNotContains(response, "Brooklyn Bridge Park")


class ParkDetailViewTest(TestCase):
    def setUp(self):
        """Set up the test client and create a test park."""
        self.client = Client()

        self.park = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Test park notes",
            google_name="Central Park",
            borough="M",
            zip_code="United States",
            formatted_address="Central Pk N, New York, NY, USA",
            latitude=40.7987768,
            longitude=-73.9537196,
            additional={
                "geometry": {
                    "bounds": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                    "location": {"lat": 40.7987768, "lng": -73.9537196},
                    "location_type": "GEOMETRIC_CENTER",
                    "viewport": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                }
            },
        )


class ReportFunctionalityTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username="reporter", password="testpass123"
        )
        self.other_user = User.objects.create_user(
            username="uploader", password="testpass123"
        )

        self.park = DogRunNew.objects.create(
            id="10",
            prop_id="9999",
            name="Test Park",
            address="Test Address",
            dogruns_type="All",
            accessible="Yes",
            formatted_address="Test Address",
            latitude=40.0,
            longitude=-73.0,
        )

        self.image = ParkImage.objects.create(
            park=self.park,
            image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
            user=self.other_user,
        )

        self.review = Review.objects.create(
            park=self.park, text="Nice place!", rating=4, user=self.other_user
        )

        self.client.login(username="reporter", password="testpass123")

    def test_report_image_creates_record(self):
        response = self.client.post(
            reverse("report_image", args=[self.image.id]),
            {"reason": "Inappropriate image"},
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self.image.reports.count(), 1)
        report = self.image.reports.first()
        self.assertEqual(report.reason, "Inappropriate image")
        self.assertEqual(report.user, self.user)

    def test_report_review_creates_record(self):
        response = self.client.post(
            reverse("park_detail", args=[self.park.id]),
            {
                "form_type": "report_review",
                "review_id": self.review.id,
                "reason": "Offensive content",
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(self.review.reports.count(), 1)
        report = self.review.reports.first()
        self.assertEqual(report.reason, "Offensive content")
        self.assertEqual(report.reported_by, self.user)

    def test_submit_review(self):
        response = self.client.post(
            reverse("park_detail", args=[self.park.id]),
            {"form_type": "submit_review", "text": "Another review!", "rating": "5"},
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(Review.objects.filter(park=self.park).count(), 2)

    def test_review_report_str(self):
        report = ReviewReport.objects.create(
            review=self.review, reported_by=self.user, reason="Inappropriate content"
        )
        self.assertIn("Reported by", str(report))
        self.assertIn(str(self.review.id), str(report))

    def test_image_report_str(self):
        report = ImageReport.objects.create(
            image=self.image, user=self.user, reason="Offensive image"
        )
        self.assertIn("Report by", str(report))
        self.assertIn(str(self.image.id), str(report))

    def test_missing_reason_does_not_create_report(self):
        self.client.login(username="user2", password="testpass")
        response = self.client.post(
            reverse("report_image", args=[self.image.id]),
            {"reason": ""},
        )
        self.assertEqual(ImageReport.objects.count(), 0)
        self.assertEqual(response.status_code, 302)


class DeleteTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(username="deleter", password="123pass")
        self.client.login(username="deleter", password="123pass")

        self.park = DogRunNew.objects.create(
            id="22",
            prop_id="9988",
            name="Del Park",
            address="Somewhere",
            dogruns_type="All",
            accessible="Yes",
            formatted_address="Addr",
            latitude=40.0,
            longitude=-73.0,
        )
        self.review = Review.objects.create(
            park=self.park, text="Review", rating=4, user=self.user
        )
        self.image = ParkImage.objects.create(
            park=self.park,
            image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
            user=self.user,
        )

    def test_delete_review(self):
        response = self.client.post(reverse("delete_review", args=[self.review.id]))
        self.assertEqual(response.status_code, 302)
        self.assertFalse(Review.objects.filter(id=self.review.id).exists())

    def test_delete_image(self):
        response = self.client.post(reverse("delete_image", args=[self.image.id]))
        self.assertEqual(response.status_code, 302)
        self.assertFalse(ParkImage.objects.filter(id=self.image.id).exists())


class ParkImageModelTest(TestCase):
    def setUp(self):
        """Set up a test park and associated images."""
        self.park = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Test park notes",
            google_name="Central Park",
            borough="M",
            zip_code="United States",
            formatted_address="Central Pk N, New York, NY, USA",
            latitude=40.7987768,
            longitude=-73.9537196,
            additional={
                "geometry": {
                    "bounds": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                    "location": {"lat": 40.7987768, "lng": -73.9537196},
                    "location_type": "GEOMETRIC_CENTER",
                    "viewport": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                }
            },
        )
        self.image = ParkImage.objects.create(
            park=self.park,
            image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
        )

    def test_park_image_creation(self):
        """Test that a ParkImage object is created successfully."""
        self.assertEqual(self.image.park, self.park)
        self.assertEqual(
            self.image.image, "https://res.cloudinary.com/demo/image/upload/sample.jpg"
        )

    def test_park_image_str(self):
        """Test the string representation of a ParkImage object."""
        self.assertEqual(str(self.image), f"Image for {self.park.name}")


class ParkDetailViewImageTest(TestCase):
    def setUp(self):
        """Set up a test park and associated images."""
        self.client = Client()
        self.park = DogRunNew.objects.create(
            id="1",
            prop_id="1234",
            name="Central Park",
            address="New York, NY",
            dogruns_type="Small",
            accessible="Yes",
            notes="Test park notes",
            google_name="Central Park",
            borough="M",
            zip_code="United States",
            formatted_address="Central Pk N, New York, NY, USA",
            latitude=40.7987768,
            longitude=-73.9537196,
            additional={
                "geometry": {
                    "bounds": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                    "location": {"lat": 40.7987768, "lng": -73.9537196},
                    "location_type": "GEOMETRIC_CENTER",
                    "viewport": {
                        "northeast": {"lat": 40.8009264, "lng": -73.9495752},
                        "southwest": {"lat": 40.796948, "lng": -73.9580246},
                    },
                }
            },
        )
        self.image = ParkImage.objects.create(
            park=self.park,
            image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
        )

    def test_park_detail_view_with_images(self):
        """Test that the park detail view displays associated images."""
        response = self.client.get(reverse("park_detail", args=[self.park.id]))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.park.name)
        # self.assertIn(self.image.image, response.content.decode())

1	from django.test import TestCase, Client	1✔
2	from django.urls import reverse	1✔
3	from django.contrib.auth.models import User	1✔
4	from .models import DogRunNew, Review, ParkImage, ReviewReport, ImageReport	1✔
5	from django.core import mail	1✔
6
7
8	# import os
9	class UniqueEmailTests(TestCase):	1✔
10	def setUp(self):	1✔
11	self.client = Client()	1✔
12	User.objects.create_user(	1✔
13	username="existinguser",
14	email="duplicate@pawpark.com",
15	password="SomeStrongPassword1",
16	)
17	self.register_url = reverse("register")	1✔
18
19	def test_duplicate_email_registration(self):	1✔
20	"""
21	Attempting to register a new user with an email that already exists should
22	re-render the form with an error message.
23	"""
24	response = self.client.post(	1✔
25	self.register_url,
26	{
27	"username": "newuser",
28	"email": "duplicate@pawpark.com",
29	"password1": "StrongPass123",
30	"password2": "StrongPass123",
31	"role": "user",
32	"admin_access_code": "",
33	},
34	)
35	self.assertEqual(response.status_code, 200)	1✔
36	self.assertContains(response, "A user with that email address already exists.")	1✔
37	self.assertFalse(User.objects.filter(username="newuser").exists())	1✔
38
39
40	class WeakPasswordTests(TestCase):	1✔
41	def setUp(self):	1✔
42	self.client = Client()	1✔
43	self.register_url = reverse("register")	1✔
44
45	def test_too_short_password(self):	1✔
46	response = self.client.post(	1✔
47	self.register_url,
48	{
49	"username": "weakuser",
50	"password1": "123",
51	"password2": "123",
52	"role": "user",
53	},
54	)
55	self.assertEqual(response.status_code, 200)	1✔
56	self.assertFalse(User.objects.filter(username="weakuser").exists())	1✔
57	self.assertContains(response, "must contain at least 8 characters")	1✔
58
59	def test_entirely_numeric_password(self):	1✔
60	response = self.client.post(	1✔
61	self.register_url,
62	{
63	"username": "numericuser",
64	"password1": "12345678",
65	"password2": "12345678",
66	"role": "user",
67	},
68	)
69	self.assertEqual(response.status_code, 200)	1✔
70	self.assertFalse(User.objects.filter(username="numericuser").exists())	1✔
71	self.assertContains(response, "can’t be entirely numeric")	1✔
72
73
74	class PasswordResetTests(TestCase):	1✔
75	def setUp(self):	1✔
76	self.client = Client()	1✔
77	self.user = User.objects.create_user(	1✔
78	"resetuser", "reset@pawpark.com", "Pass123456"
79	)
80
81	def test_password_reset_page_loads(self):	1✔
82	url = reverse("password_reset")	1✔
83	response = self.client.get(url)	1✔
84	self.assertEqual(response.status_code, 200)	1✔
85	self.assertTemplateUsed(response, "registration/password_reset_form.html")	1✔
86
87	def test_password_reset_flow(self):	1✔
88	"""
89	Ensure that posting an email to password_reset
90	sends the user to password_reset_done,
91	and optionally check that an email was
92	"sent" (console backend or etc.)
93	"""
94	url = reverse("password_reset")	1✔
95	response = self.client.post(url, {"email": "reset@pawpark.com"})	1✔
96	self.assertEqual(response.status_code, 302)	1✔
97	self.assertRedirects(response, reverse("password_reset_done"))	1✔
98
99	self.assertEqual(len(mail.outbox), 1)	1✔
100	self.assertIn("resetuser", mail.outbox[0].body)	1✔
101
102
103	class AdminSignUpTests(TestCase):	1✔
104	def setUp(self):	1✔
105	self.client = Client()	1✔
106	self.register_url = reverse("register")	1✔
107
108	def test_admin_signup_with_correct_code(self):	1✔
109	"""
110	Signing up as admin with correct access code should create a staff user.
111	"""
112	response = self.client.post(	1✔
113	self.register_url,
114	{
115	"username": "adminuser",
116	"password1": "StrongAdminPass123",
117	"password2": "StrongAdminPass123",
118	"role": "admin",
119	"admin_access_code": "SUPERDOG123",
120	},
121	)
122	self.assertEqual(response.status_code, 302)	1✔
123	self.assertTrue(User.objects.filter(username="adminuser").exists())	1✔
124	user = User.objects.get(username="adminuser")	1✔
125	self.assertTrue(user.is_staff)	1✔
126
127	def test_admin_signup_with_wrong_code(self):	1✔
128	"""
129	Signing up as admin with wrong code should fail and not create staff user.
130	"""
131	response = self.client.post(	1✔
132	self.register_url,
133	{
134	"username": "fakeadmin",
135	"password1": "StrongAdminPass123",
136	"password2": "StrongAdminPass123",
137	"role": "admin",
138	"admin_access_code": "WRONGCODE",
139	},
140	)
141	self.assertEqual(response.status_code, 200)	1✔
142	self.assertFalse(User.objects.filter(username="fakeadmin").exists())	1✔
143
144	def test_signup_as_normal_user_ignores_access_code(self):	1✔
145	"""
146	If someone chooses 'user' role, the admin_access_code is irrelevant.
147	"""
148	response = self.client.post(	1✔
149	self.register_url,
150	{
151	"username": "normaluser",
152	"password1": "StrongPass456",
153	"password2": "StrongPass456",
154	"role": "user",
155	"admin_access_code": "SUPERDOG123",
156	},
157	)
158	self.assertEqual(response.status_code, 302)	1✔
159	self.assertTrue(User.objects.filter(username="normaluser").exists())	1✔
160	user = User.objects.get(username="normaluser")	1✔
161	self.assertFalse(user.is_staff)	1✔
162
163
164	class LoginTests(TestCase):	1✔
165	def setUp(self):	1✔
166	self.client = Client()	1✔
167	self.user = User.objects.create_user(	1✔
168	username="testuser", password="StrongPass123"
169	)
170
171	def test_login_page_loads(self):	1✔
172	"""Ensure the login page loads properly."""
173	response = self.client.get(reverse("login"))	1✔
174	self.assertEqual(response.status_code, 200)	1✔
175	self.assertTemplateUsed(response, "parks/login.html")	1✔
176
177	def test_valid_login(self):	1✔
178	"""Ensure a valid user can log in."""
179	response = self.client.post(	1✔
180	reverse("login"), {"username": "testuser", "password": "StrongPass123"}
181	)
182	self.assertEqual(response.status_code, 302)	1✔
183
184
185	class AuthTests(TestCase):	1✔
186	def setUp(self):	1✔
187	self.client = Client()	1✔
188
189	def test_register_page_loads(self):	1✔
190	"""Ensure the registration page loads properly."""
191	response = self.client.get(reverse("register"))	1✔
192	self.assertEqual(response.status_code, 200)	1✔
193	self.assertTemplateUsed(response, "parks/register.html")	1✔
194
195	def test_user_registration(self):	1✔
196	"""Ensure a new user can register successfully."""
197	response = self.client.post(	1✔
198	reverse("register"),
199	{
200	"username": "testuser",
201	"password1": "StrongPass123",
202	"password2": "StrongPass123",
203	"role": "user", # Ensure this field is required
204	},
205	)
206	self.assertEqual(response.status_code, 302)	1✔
207	self.assertTrue(User.objects.filter(username="testuser").exists())	1✔
208
209
210	class ParkModelTest(TestCase):	1✔
211	def setUp(self):	1✔
212	self.client = Client()	1✔
213	self.park = DogRunNew.objects.create(	1✔
214	id="1",
215	prop_id="1234",
216	name="Central Park",
217	address="New York, NY",
218	dogruns_type="Small",
219	accessible="Yes",
220	notes="Test park notes",
221	google_name="Central Park",
222	borough="M",
223	zip_code="United States",
224	formatted_address="Central Pk N, New York, NY, USA",
225	latitude=40.7987768,
226	longitude=-73.9537196,
227	additional={
228	"geometry": {
229	"bounds": {
230	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
231	"southwest": {"lat": 40.796948, "lng": -73.9580246},
232	},
233	"location": {"lat": 40.7987768, "lng": -73.9537196},
234	"location_type": "GEOMETRIC_CENTER",
235	"viewport": {
236	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
237	"southwest": {"lat": 40.796948, "lng": -73.9580246},
238	},
239	}
240	},
241	)
242
243	def test_park_creation(self):	1✔
244	self.assertEqual(self.park.name, "Central Park")	1✔
245	self.assertEqual(self.park.address, "New York, NY")	1✔
246	self.assertEqual(self.park.notes, "Test park notes")	1✔
247
248
249	class ReviewModelTest(TestCase):	1✔
250	def setUp(self):	1✔
251	self.user = User.objects.create_user(username="testuser", password="123456abc")	1✔
252	self.park = DogRunNew.objects.create(	1✔
253	id="2",
254	prop_id="5678",
255	name="Brooklyn Park",
256	address="Brooklyn, NY",
257	dogruns_type="Large",
258	accessible="No",
259	notes="Another test park",
260	)
261	self.review = Review.objects.create(	1✔
262	park=self.park, text="Great park!", rating=5, user=self.user
263	)
264
265	def test_review_creation(self):	1✔
266	self.assertEqual(self.review.text, "Great park!")	1✔
267	self.assertEqual(self.review.rating, 5)	1✔
268	self.assertEqual(self.review.park.name, "Brooklyn Park")	1✔
269
270	def test_review_str_method(self):	1✔
271	self.assertEqual(str(self.review), "Review for Brooklyn Park (5 stars)")	1✔
272
273
274	class ParkListViewTest(TestCase):	1✔
275	def setUp(self):	1✔
276	self.client = Client()	1✔
277	self.park = DogRunNew.objects.create(	1✔
278	id="1",
279	prop_id="1234",
280	name="Central Park",
281	address="New York, NY",
282	dogruns_type="Small",
283	accessible="Yes",
284	notes="Test park notes",
285	google_name="Central Park",
286	borough="M",
287	zip_code="United States",
288	formatted_address="Central Pk N, New York, NY, USA",
289	latitude=40.7987768,
290	longitude=-73.9537196,
291	additional={
292	"geometry": {
293	"bounds": {
294	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
295	"southwest": {"lat": 40.796948, "lng": -73.9580246},
296	},
297	"location": {"lat": 40.7987768, "lng": -73.9537196},
298	"location_type": "GEOMETRIC_CENTER",
299	"viewport": {
300	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
301	"southwest": {"lat": 40.796948, "lng": -73.9580246},
302	},
303	}
304	},
305	)
306
307	def test_park_list_view(self):	1✔
308	response = self.client.get(reverse("park_list"))	1✔
309	self.assertEqual(response.status_code, 200)	1✔
310	self.assertContains(response, "Central Park")	1✔
311
312
313	class MapViewTest(TestCase):	1✔
314	def setUp(self):	1✔
315	self.client = Client()	1✔
316
317	def test_map_view(self):	1✔
318	response = self.client.get(reverse("map"))	1✔
319	self.assertEqual(response.status_code, 200)	1✔
320
321
322	class CombinedViewTest(TestCase):	1✔
323	def test_combined_view(self):	1✔
324	response = self.client.get(reverse("park_and_map"))	1✔
325	self.assertEqual(response.status_code, 200)	1✔
326
327	def setUp(self):	1✔
328	self.client = Client()	1✔
329	# One park in Manhattan
330	self.park_manhattan = DogRunNew.objects.create(	1✔
331	id="1",
332	prop_id="1234",
333	name="Central Park",
334	address="New York, NY",
335	dogruns_type="Small",
336	accessible="Yes",
337	notes="Manhattan park",
338	google_name="Central Park",
339	borough="M",
340	zip_code="10024",
341	latitude=40.7987768,
342	longitude=-73.9537196,
343	)
344	# One park in Brooklyn
345	self.park_brooklyn = DogRunNew.objects.create(	1✔
346	id="2",
347	prop_id="5678",
348	name="Brooklyn Bridge Park",
349	address="Brooklyn, NY",
350	dogruns_type="Large",
351	accessible="Yes",
352	notes="Brooklyn park",
353	google_name="Brooklyn Bridge Park",
354	borough="B",
355	zip_code="11201",
356	latitude=40.700292,
357	longitude=-73.996123,
358	)
359
360	def test_combined_view_filters_by_borough(self):	1✔
361	response = self.client.get(reverse("park_and_map"), {"borough": "M"})	1✔
362	self.assertEqual(response.status_code, 200)	1✔
363	self.assertContains(response, "Central Park")	1✔
364	self.assertNotContains(response, "Brooklyn Bridge Park")	1✔
365
366
367	class ParkDetailViewTest(TestCase):	1✔
368	def setUp(self):	1✔
369	"""Set up the test client and create a test park."""
370	self.client = Client()	×
371
372	self.park = DogRunNew.objects.create(	×
373	id="1",
374	prop_id="1234",
375	name="Central Park",
376	address="New York, NY",
377	dogruns_type="Small",
378	accessible="Yes",
379	notes="Test park notes",
380	google_name="Central Park",
381	borough="M",
382	zip_code="United States",
383	formatted_address="Central Pk N, New York, NY, USA",
384	latitude=40.7987768,
385	longitude=-73.9537196,
386	additional={
387	"geometry": {
388	"bounds": {
389	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
390	"southwest": {"lat": 40.796948, "lng": -73.9580246},
391	},
392	"location": {"lat": 40.7987768, "lng": -73.9537196},
393	"location_type": "GEOMETRIC_CENTER",
394	"viewport": {
395	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
396	"southwest": {"lat": 40.796948, "lng": -73.9580246},
397	},
398	}
399	},
400	)
401
402
403	class ReportFunctionalityTests(TestCase):	1✔
404	def setUp(self):	1✔
405	self.client = Client()	1✔
406	self.user = User.objects.create_user(	1✔
407	username="reporter", password="testpass123"
408	)
409	self.other_user = User.objects.create_user(	1✔
410	username="uploader", password="testpass123"
411	)
412
413	self.park = DogRunNew.objects.create(	1✔
414	id="10",
415	prop_id="9999",
416	name="Test Park",
417	address="Test Address",
418	dogruns_type="All",
419	accessible="Yes",
420	formatted_address="Test Address",
421	latitude=40.0,
422	longitude=-73.0,
423	)
424
425	self.image = ParkImage.objects.create(	1✔
426	park=self.park,
427	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
428	user=self.other_user,
429	)
430
431	self.review = Review.objects.create(	1✔
432	park=self.park, text="Nice place!", rating=4, user=self.other_user
433	)
434
435	self.client.login(username="reporter", password="testpass123")	1✔
436
437	def test_report_image_creates_record(self):	1✔
438	response = self.client.post(	1✔
439	reverse("report_image", args=[self.image.id]),
440	{"reason": "Inappropriate image"},
441	)
442	self.assertEqual(response.status_code, 302)	1✔
443	self.assertEqual(self.image.reports.count(), 1)	1✔
444	report = self.image.reports.first()	1✔
445	self.assertEqual(report.reason, "Inappropriate image")	1✔
446	self.assertEqual(report.user, self.user)	1✔
447
448	def test_report_review_creates_record(self):	1✔
449	response = self.client.post(	1✔
450	reverse("park_detail", args=[self.park.id]),
451	{
452	"form_type": "report_review",
453	"review_id": self.review.id,
454	"reason": "Offensive content",
455	},
456	)
457	self.assertEqual(response.status_code, 302)	1✔
458	self.assertEqual(self.review.reports.count(), 1)	1✔
459	report = self.review.reports.first()	1✔
460	self.assertEqual(report.reason, "Offensive content")	1✔
461	self.assertEqual(report.reported_by, self.user)	1✔
462
463	def test_submit_review(self):	1✔
464	response = self.client.post(	1✔
465	reverse("park_detail", args=[self.park.id]),
466	{"form_type": "submit_review", "text": "Another review!", "rating": "5"},
467	)
468	self.assertEqual(response.status_code, 302)	1✔
469	self.assertEqual(Review.objects.filter(park=self.park).count(), 2)	1✔
470
471	def test_review_report_str(self):	1✔
472	report = ReviewReport.objects.create(	1✔
473	review=self.review, reported_by=self.user, reason="Inappropriate content"
474	)
475	self.assertIn("Reported by", str(report))	1✔
476	self.assertIn(str(self.review.id), str(report))	1✔
477
478	def test_image_report_str(self):	1✔
479	report = ImageReport.objects.create(	1✔
480	image=self.image, user=self.user, reason="Offensive image"
481	)
482	self.assertIn("Report by", str(report))	1✔
483	self.assertIn(str(self.image.id), str(report))	1✔
484
485	def test_missing_reason_does_not_create_report(self):	1✔
486	self.client.login(username="user2", password="testpass")	1✔
487	response = self.client.post(	1✔
488	reverse("report_image", args=[self.image.id]),
489	{"reason": ""},
490	)
491	self.assertEqual(ImageReport.objects.count(), 0)	1✔
492	self.assertEqual(response.status_code, 302)	1✔
493
494
495	class DeleteTests(TestCase):	1✔
496	def setUp(self):	1✔
497	self.client = Client()	1✔
498	self.user = User.objects.create_user(username="deleter", password="123pass")	1✔
499	self.client.login(username="deleter", password="123pass")	1✔
500
501	self.park = DogRunNew.objects.create(	1✔
502	id="22",
503	prop_id="9988",
504	name="Del Park",
505	address="Somewhere",
506	dogruns_type="All",
507	accessible="Yes",
508	formatted_address="Addr",
509	latitude=40.0,
510	longitude=-73.0,
511	)
512	self.review = Review.objects.create(	1✔
513	park=self.park, text="Review", rating=4, user=self.user
514	)
515	self.image = ParkImage.objects.create(	1✔
516	park=self.park,
517	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
518	user=self.user,
519	)
520
521	def test_delete_review(self):	1✔
522	response = self.client.post(reverse("delete_review", args=[self.review.id]))	1✔
523	self.assertEqual(response.status_code, 302)	1✔
524	self.assertFalse(Review.objects.filter(id=self.review.id).exists())	1✔
525
526	def test_delete_image(self):	1✔
527	response = self.client.post(reverse("delete_image", args=[self.image.id]))	1✔
528	self.assertEqual(response.status_code, 302)	1✔
529	self.assertFalse(ParkImage.objects.filter(id=self.image.id).exists())	1✔
530
531
532	class ParkImageModelTest(TestCase):	1✔
533	def setUp(self):	1✔
534	"""Set up a test park and associated images."""
535	self.park = DogRunNew.objects.create(	1✔
536	id="1",
537	prop_id="1234",
538	name="Central Park",
539	address="New York, NY",
540	dogruns_type="Small",
541	accessible="Yes",
542	notes="Test park notes",
543	google_name="Central Park",
544	borough="M",
545	zip_code="United States",
546	formatted_address="Central Pk N, New York, NY, USA",
547	latitude=40.7987768,
548	longitude=-73.9537196,
549	additional={
550	"geometry": {
551	"bounds": {
552	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
553	"southwest": {"lat": 40.796948, "lng": -73.9580246},
554	},
555	"location": {"lat": 40.7987768, "lng": -73.9537196},
556	"location_type": "GEOMETRIC_CENTER",
557	"viewport": {
558	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
559	"southwest": {"lat": 40.796948, "lng": -73.9580246},
560	},
561	}
562	},
563	)
564	self.image = ParkImage.objects.create(	1✔
565	park=self.park,
566	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
567	)
568
569	def test_park_image_creation(self):	1✔
570	"""Test that a ParkImage object is created successfully."""
571	self.assertEqual(self.image.park, self.park)	1✔
572	self.assertEqual(	1✔
573	self.image.image, "https://res.cloudinary.com/demo/image/upload/sample.jpg"
574	)
575
576	def test_park_image_str(self):	1✔
577	"""Test the string representation of a ParkImage object."""
578	self.assertEqual(str(self.image), f"Image for {self.park.name}")	1✔
579
580
581	class ParkDetailViewImageTest(TestCase):	1✔
582	def setUp(self):	1✔
583	"""Set up a test park and associated images."""
584	self.client = Client()	1✔
585	self.park = DogRunNew.objects.create(	1✔
586	id="1",
587	prop_id="1234",
588	name="Central Park",
589	address="New York, NY",
590	dogruns_type="Small",
591	accessible="Yes",
592	notes="Test park notes",
593	google_name="Central Park",
594	borough="M",
595	zip_code="United States",
596	formatted_address="Central Pk N, New York, NY, USA",
597	latitude=40.7987768,
598	longitude=-73.9537196,
599	additional={
600	"geometry": {
601	"bounds": {
602	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
603	"southwest": {"lat": 40.796948, "lng": -73.9580246},
604	},
605	"location": {"lat": 40.7987768, "lng": -73.9537196},
606	"location_type": "GEOMETRIC_CENTER",
607	"viewport": {
608	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
609	"southwest": {"lat": 40.796948, "lng": -73.9580246},
610	},
611	}
612	},
613	)
614	self.image = ParkImage.objects.create(	1✔
615	park=self.park,
616	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
617	)
618
619	def test_park_detail_view_with_images(self):	1✔
620	"""Test that the park detail view displays associated images."""
621	response = self.client.get(reverse("park_detail", args=[self.park.id]))	1✔
622	self.assertEqual(response.status_code, 200)	1✔
623	self.assertContains(response, self.park.name)	1✔
624	# self.assertIn(self.image.image, response.content.decode())

gcivil-nyu-org / team4-wed-spring25 / 372

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous