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

Committed 02 Apr 2025 11:02PM UTC coverage: 96.534% (-0.2%) from 96.692%

Build # 343

Build Type

cron

travis-pro

Committed by

web-flow

Commit Message

Merge pull request #191 from gcivil-nyu-org/develop

Merge Develop to main

Run Details

133 of 137 new or added lines in 6 files covered. (97.08%)

4 existing lines in 2 files now uncovered.

752 of 779 relevant lines covered (96.53%)

0.97 hits per line

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

98.67

/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


# import os


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
6
7	# import os
8
9
10	class LoginTests(TestCase):	1✔
11	def setUp(self):	1✔
12	self.client = Client()	1✔
13	self.user = User.objects.create_user(	1✔
14	username="testuser", password="StrongPass123"
15	)
16
17	def test_login_page_loads(self):	1✔
18	"""Ensure the login page loads properly."""
19	response = self.client.get(reverse("login"))	1✔
20	self.assertEqual(response.status_code, 200)	1✔
21	self.assertTemplateUsed(response, "parks/login.html")	1✔
22
23	def test_valid_login(self):	1✔
24	"""Ensure a valid user can log in."""
25	response = self.client.post(	1✔
26	reverse("login"), {"username": "testuser", "password": "StrongPass123"}
27	)
28	self.assertEqual(response.status_code, 302)	1✔
29
30
31	class AuthTests(TestCase):	1✔
32	def setUp(self):	1✔
33	self.client = Client()	1✔
34
35	def test_register_page_loads(self):	1✔
36	"""Ensure the registration page loads properly."""
37	response = self.client.get(reverse("register"))	1✔
38	self.assertEqual(response.status_code, 200)	1✔
39	self.assertTemplateUsed(response, "parks/register.html")	1✔
40
41	def test_user_registration(self):	1✔
42	"""Ensure a new user can register successfully."""
43	response = self.client.post(	1✔
44	reverse("register"),
45	{
46	"username": "testuser",
47	"password1": "StrongPass123",
48	"password2": "StrongPass123",
49	"role": "user", # Ensure this field is required
50	},
51	)
52	self.assertEqual(response.status_code, 302)	1✔
53	self.assertTrue(User.objects.filter(username="testuser").exists())	1✔
54
55
56	class ParkModelTest(TestCase):	1✔
57	def setUp(self):	1✔
58	self.client = Client()	1✔
59	self.park = DogRunNew.objects.create(	1✔
60	id="1",
61	prop_id="1234",
62	name="Central Park",
63	address="New York, NY",
64	dogruns_type="Small",
65	accessible="Yes",
66	notes="Test park notes",
67	google_name="Central Park",
68	borough="M",
69	zip_code="United States",
70	formatted_address="Central Pk N, New York, NY, USA",
71	latitude=40.7987768,
72	longitude=-73.9537196,
73	additional={
74	"geometry": {
75	"bounds": {
76	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
77	"southwest": {"lat": 40.796948, "lng": -73.9580246},
78	},
79	"location": {"lat": 40.7987768, "lng": -73.9537196},
80	"location_type": "GEOMETRIC_CENTER",
81	"viewport": {
82	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
83	"southwest": {"lat": 40.796948, "lng": -73.9580246},
84	},
85	}
86	},
87	)
88
89	def test_park_creation(self):	1✔
90	self.assertEqual(self.park.name, "Central Park")	1✔
91	self.assertEqual(self.park.address, "New York, NY")	1✔
92	self.assertEqual(self.park.notes, "Test park notes")	1✔
93
94
95	class ReviewModelTest(TestCase):	1✔
96	def setUp(self):	1✔
97	self.user = User.objects.create_user(username="testuser", password="123456abc")	1✔
98	self.park = DogRunNew.objects.create(	1✔
99	id="2",
100	prop_id="5678",
101	name="Brooklyn Park",
102	address="Brooklyn, NY",
103	dogruns_type="Large",
104	accessible="No",
105	notes="Another test park",
106	)
107	self.review = Review.objects.create(	1✔
108	park=self.park, text="Great park!", rating=5, user=self.user
109	)
110
111	def test_review_creation(self):	1✔
112	self.assertEqual(self.review.text, "Great park!")	1✔
113	self.assertEqual(self.review.rating, 5)	1✔
114	self.assertEqual(self.review.park.name, "Brooklyn Park")	1✔
115
116	def test_review_str_method(self):	1✔
117	self.assertEqual(str(self.review), "Review for Brooklyn Park (5 stars)")	1✔
118
119
120	class ParkListViewTest(TestCase):	1✔
121	def setUp(self):	1✔
122	self.client = Client()	1✔
123	self.park = DogRunNew.objects.create(	1✔
124	id="1",
125	prop_id="1234",
126	name="Central Park",
127	address="New York, NY",
128	dogruns_type="Small",
129	accessible="Yes",
130	notes="Test park notes",
131	google_name="Central Park",
132	borough="M",
133	zip_code="United States",
134	formatted_address="Central Pk N, New York, NY, USA",
135	latitude=40.7987768,
136	longitude=-73.9537196,
137	additional={
138	"geometry": {
139	"bounds": {
140	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
141	"southwest": {"lat": 40.796948, "lng": -73.9580246},
142	},
143	"location": {"lat": 40.7987768, "lng": -73.9537196},
144	"location_type": "GEOMETRIC_CENTER",
145	"viewport": {
146	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
147	"southwest": {"lat": 40.796948, "lng": -73.9580246},
148	},
149	}
150	},
151	)
152
153	def test_park_list_view(self):	1✔
154	response = self.client.get(reverse("park_list"))	1✔
155	self.assertEqual(response.status_code, 200)	1✔
156	self.assertContains(response, "Central Park")	1✔
157
158
159	class MapViewTest(TestCase):	1✔
160	def setUp(self):	1✔
161	self.client = Client()	1✔
162
163	def test_map_view(self):	1✔
164	response = self.client.get(reverse("map"))	1✔
165	self.assertEqual(response.status_code, 200)	1✔
166
167
168	class CombinedViewTest(TestCase):	1✔
169	def test_combined_view(self):	1✔
170	response = self.client.get(reverse("park_and_map"))	1✔
171	self.assertEqual(response.status_code, 200)	1✔
172
173	def setUp(self):	1✔
174	self.client = Client()	1✔
175	# One park in Manhattan
176	self.park_manhattan = DogRunNew.objects.create(	1✔
177	id="1",
178	prop_id="1234",
179	name="Central Park",
180	address="New York, NY",
181	dogruns_type="Small",
182	accessible="Yes",
183	notes="Manhattan park",
184	google_name="Central Park",
185	borough="M",
186	zip_code="10024",
187	latitude=40.7987768,
188	longitude=-73.9537196,
189	)
190	# One park in Brooklyn
191	self.park_brooklyn = DogRunNew.objects.create(	1✔
192	id="2",
193	prop_id="5678",
194	name="Brooklyn Bridge Park",
195	address="Brooklyn, NY",
196	dogruns_type="Large",
197	accessible="Yes",
198	notes="Brooklyn park",
199	google_name="Brooklyn Bridge Park",
200	borough="B",
201	zip_code="11201",
202	latitude=40.700292,
203	longitude=-73.996123,
204	)
205
206	def test_combined_view_filters_by_borough(self):	1✔
207	response = self.client.get(reverse("park_and_map"), {"borough": "M"})	1✔
208	self.assertEqual(response.status_code, 200)	1✔
209	self.assertContains(response, "Central Park")	1✔
210	self.assertNotContains(response, "Brooklyn Bridge Park")	1✔
211
212
213	class ParkDetailViewTest(TestCase):	1✔
214	def setUp(self):	1✔
215	"""Set up the test client and create a test park."""
UNCOV 216	self.client = Client()	×
217
UNCOV 218	self.park = DogRunNew.objects.create(	×
219	id="1",
220	prop_id="1234",
221	name="Central Park",
222	address="New York, NY",
223	dogruns_type="Small",
224	accessible="Yes",
225	notes="Test park notes",
226	google_name="Central Park",
227	borough="M",
228	zip_code="United States",
229	formatted_address="Central Pk N, New York, NY, USA",
230	latitude=40.7987768,
231	longitude=-73.9537196,
232	additional={
233	"geometry": {
234	"bounds": {
235	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
236	"southwest": {"lat": 40.796948, "lng": -73.9580246},
237	},
238	"location": {"lat": 40.7987768, "lng": -73.9537196},
239	"location_type": "GEOMETRIC_CENTER",
240	"viewport": {
241	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
242	"southwest": {"lat": 40.796948, "lng": -73.9580246},
243	},
244	}
245	},
246	)
247
248
249	class ReportFunctionalityTests(TestCase):	1✔
250	def setUp(self):	1✔
251	self.client = Client()	1✔
252	self.user = User.objects.create_user(	1✔
253	username="reporter", password="testpass123"
254	)
255	self.other_user = User.objects.create_user(	1✔
256	username="uploader", password="testpass123"
257	)
258
259	self.park = DogRunNew.objects.create(	1✔
260	id="10",
261	prop_id="9999",
262	name="Test Park",
263	address="Test Address",
264	dogruns_type="All",
265	accessible="Yes",
266	formatted_address="Test Address",
267	latitude=40.0,
268	longitude=-73.0,
269	)
270
271	self.image = ParkImage.objects.create(	1✔
272	park=self.park,
273	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
274	user=self.other_user,
275	)
276
277	self.review = Review.objects.create(	1✔
278	park=self.park, text="Nice place!", rating=4, user=self.other_user
279	)
280
281	self.client.login(username="reporter", password="testpass123")	1✔
282
283	def test_report_image_creates_record(self):	1✔
284	response = self.client.post(	1✔
285	reverse("report_image", args=[self.image.id]),
286	{"reason": "Inappropriate image"},
287	)
288	self.assertEqual(response.status_code, 302)	1✔
289	self.assertEqual(self.image.reports.count(), 1)	1✔
290	report = self.image.reports.first()	1✔
291	self.assertEqual(report.reason, "Inappropriate image")	1✔
292	self.assertEqual(report.user, self.user)	1✔
293
294	def test_report_review_creates_record(self):	1✔
295	response = self.client.post(	1✔
296	reverse("park_detail", args=[self.park.id]),
297	{
298	"form_type": "report_review",
299	"review_id": self.review.id,
300	"reason": "Offensive content",
301	},
302	)
303	self.assertEqual(response.status_code, 302)	1✔
304	self.assertEqual(self.review.reports.count(), 1)	1✔
305	report = self.review.reports.first()	1✔
306	self.assertEqual(report.reason, "Offensive content")	1✔
307	self.assertEqual(report.reported_by, self.user)	1✔
308
309	def test_submit_review(self):	1✔
310	response = self.client.post(	1✔
311	reverse("park_detail", args=[self.park.id]),
312	{"form_type": "submit_review", "text": "Another review!", "rating": "5"},
313	)
314	self.assertEqual(response.status_code, 302)	1✔
315	self.assertEqual(Review.objects.filter(park=self.park).count(), 2)	1✔
316
317	def test_review_report_str(self):	1✔
318	report = ReviewReport.objects.create(	1✔
319	review=self.review, reported_by=self.user, reason="Inappropriate content"
320	)
321	self.assertIn("Reported by", str(report))	1✔
322	self.assertIn(str(self.review.id), str(report))	1✔
323
324	def test_image_report_str(self):	1✔
325	report = ImageReport.objects.create(	1✔
326	image=self.image, user=self.user, reason="Offensive image"
327	)
328	self.assertIn("Report by", str(report))	1✔
329	self.assertIn(str(self.image.id), str(report))	1✔
330
331	def test_missing_reason_does_not_create_report(self):	1✔
332	self.client.login(username="user2", password="testpass")	1✔
333	response = self.client.post(	1✔
334	reverse("report_image", args=[self.image.id]),
335	{"reason": ""},
336	)
337	self.assertEqual(ImageReport.objects.count(), 0)	1✔
338	self.assertEqual(response.status_code, 302)	1✔
339
340
341	class DeleteTests(TestCase):	1✔
342	def setUp(self):	1✔
343	self.client = Client()	1✔
344	self.user = User.objects.create_user(username="deleter", password="123pass")	1✔
345	self.client.login(username="deleter", password="123pass")	1✔
346
347	self.park = DogRunNew.objects.create(	1✔
348	id="22",
349	prop_id="9988",
350	name="Del Park",
351	address="Somewhere",
352	dogruns_type="All",
353	accessible="Yes",
354	formatted_address="Addr",
355	latitude=40.0,
356	longitude=-73.0,
357	)
358	self.review = Review.objects.create(	1✔
359	park=self.park, text="Review", rating=4, user=self.user
360	)
361	self.image = ParkImage.objects.create(	1✔
362	park=self.park,
363	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
364	user=self.user,
365	)
366
367	def test_delete_review(self):	1✔
368	response = self.client.post(reverse("delete_review", args=[self.review.id]))	1✔
369	self.assertEqual(response.status_code, 302)	1✔
370	self.assertFalse(Review.objects.filter(id=self.review.id).exists())	1✔
371
372	def test_delete_image(self):	1✔
373	response = self.client.post(reverse("delete_image", args=[self.image.id]))	1✔
374	self.assertEqual(response.status_code, 302)	1✔
375	self.assertFalse(ParkImage.objects.filter(id=self.image.id).exists())	1✔
376
377
378	class ParkImageModelTest(TestCase):	1✔
379	def setUp(self):	1✔
380	"""Set up a test park and associated images."""
381	self.park = DogRunNew.objects.create(	1✔
382	id="1",
383	prop_id="1234",
384	name="Central Park",
385	address="New York, NY",
386	dogruns_type="Small",
387	accessible="Yes",
388	notes="Test park notes",
389	google_name="Central Park",
390	borough="M",
391	zip_code="United States",
392	formatted_address="Central Pk N, New York, NY, USA",
393	latitude=40.7987768,
394	longitude=-73.9537196,
395	additional={
396	"geometry": {
397	"bounds": {
398	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
399	"southwest": {"lat": 40.796948, "lng": -73.9580246},
400	},
401	"location": {"lat": 40.7987768, "lng": -73.9537196},
402	"location_type": "GEOMETRIC_CENTER",
403	"viewport": {
404	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
405	"southwest": {"lat": 40.796948, "lng": -73.9580246},
406	},
407	}
408	},
409	)
410	self.image = ParkImage.objects.create(	1✔
411	park=self.park,
412	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
413	)
414
415	def test_park_image_creation(self):	1✔
416	"""Test that a ParkImage object is created successfully."""
417	self.assertEqual(self.image.park, self.park)	1✔
418	self.assertEqual(	1✔
419	self.image.image, "https://res.cloudinary.com/demo/image/upload/sample.jpg"
420	)
421
422	def test_park_image_str(self):	1✔
423	"""Test the string representation of a ParkImage object."""
424	self.assertEqual(str(self.image), f"Image for {self.park.name}")	1✔
425
426
427	class ParkDetailViewImageTest(TestCase):	1✔
428	def setUp(self):	1✔
429	"""Set up a test park and associated images."""
430	self.client = Client()	1✔
431	self.park = DogRunNew.objects.create(	1✔
432	id="1",
433	prop_id="1234",
434	name="Central Park",
435	address="New York, NY",
436	dogruns_type="Small",
437	accessible="Yes",
438	notes="Test park notes",
439	google_name="Central Park",
440	borough="M",
441	zip_code="United States",
442	formatted_address="Central Pk N, New York, NY, USA",
443	latitude=40.7987768,
444	longitude=-73.9537196,
445	additional={
446	"geometry": {
447	"bounds": {
448	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
449	"southwest": {"lat": 40.796948, "lng": -73.9580246},
450	},
451	"location": {"lat": 40.7987768, "lng": -73.9537196},
452	"location_type": "GEOMETRIC_CENTER",
453	"viewport": {
454	"northeast": {"lat": 40.8009264, "lng": -73.9495752},
455	"southwest": {"lat": 40.796948, "lng": -73.9580246},
456	},
457	}
458	},
459	)
460	self.image = ParkImage.objects.create(	1✔
461	park=self.park,
462	image="https://res.cloudinary.com/demo/image/upload/sample.jpg",
463	)
464
465	def test_park_detail_view_with_images(self):	1✔
466	"""Test that the park detail view displays associated images."""
467	response = self.client.get(reverse("park_detail", args=[self.park.id]))	1✔
468	self.assertEqual(response.status_code, 200)	1✔
469	self.assertContains(response, self.park.name)	1✔
470	# self.assertIn(self.image.image, response.content.decode())

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

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