#614972427

Committed 12 Dec 2023 09:36PM UTC coverage: 93.876% (+8.7%) from 85.196%

Build # #614972427

Build Type

Pull #153

travis-ci

Pull Request Pull Request #153: Merge to Master 12.12.23. Before Final Presentation

Run Details

246 of 264 new or added lines in 11 files covered. (93.18%)

1 existing line in 1 file now uncovered.

1211 of 1290 relevant lines covered (93.88%)

0.94 hits per line

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

99.1

/map/tests.py

from django.test import TestCase
from django.urls import reverse
from django.utils import timezone

from users.models import User, Post, UserVerification
from .models import ParkingSpace
from .views import ParkingSpaceView
from .forms import CreateParkingSpaceForm


USERNAME = "parkrowd"
EMAIL = "parkrowd@gmail.com"
PASSWORD = "iLikeParking123!"
DUMMY_PASSWORD = "noParkingForYou"

PARKING_SPOT_ID = "12657"
ADDRESS_ZIP = "10001"
LONGITUDE = "-73.9853043125"
LATITUDE = "40.7486538125"
PARKING_SPOT_NAME = "Empire State Building"

TITLE = "Parking Here For 15 Minutes"
POST = "After 3:15, I'll be gone."
DATE = timezone.now()

POST_PATH_NAME = "map:post"
ADD_SPOT_PATH_NAME = "map:add-parking-space"
REDIRECT_SPOT_PATH_NAME = "map:spot-redirect"
MAP_PATH_NAME = "map:parking"
POST_TEMPLATE = "map/post.html"


class MapViewTests(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username=USERNAME, email=EMAIL, password=PASSWORD
        )
        self.user_verification = UserVerification.objects.create(
            username=self.user, status="verified"
        )

    def test_non_authenticated_user(self):
        response = self.client.get(reverse(MAP_PATH_NAME))
        self.assertEqual(response.status_code, 200)

        # * Check if the user_verification is NOT present in the context
        self.assertIsNone(response.context.get("user_verification"))

    def test_authenticated_user(self):
        self.client.login(username=USERNAME, password=PASSWORD)
        response = self.client.get(reverse(MAP_PATH_NAME))
        self.assertEqual(response.status_code, 200)

        # * Check if the user_verification is present in the context
        self.assertIsNotNone(response.context.get("user_verification"))


class ParkingSpaceViewTests(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username=USERNAME, email=EMAIL, password=PASSWORD
        )
        self.user_verification = UserVerification.objects.create(
            username=self.user, status="verified"
        )

    def test_get_view(self):
        self.client.login(username=USERNAME, password=PASSWORD)
        response_no_lat_lon = self.client.get(reverse(ADD_SPOT_PATH_NAME))
        self.assertEqual(response_no_lat_lon.status_code, 200)
        self.assertEqual(
            response_no_lat_lon.context.get("error"),
            "Unable to collect longitude and latitude from URL. Please check if the URL is correct.",
        )
        self.assertIsNotNone(response_no_lat_lon.context.get("user_verification"))

        response_with_lat_lon = self.client.get(
            reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456"
        )
        self.assertEqual(response_with_lat_lon.status_code, 200)
        self.assertIsNone(response_with_lat_lon.context.get("error"))
        self.assertIsNotNone(response_with_lat_lon.context.get("user_verification"))

    def test_get_next_parking_space_id(self):
        parking_space_view = ParkingSpaceView()
        id = parking_space_view._ParkingSpaceView__get_next_parkingspace_id()
        self.assertEqual(id, "1")

        # * Test if adding new record generates new ID of 2
        self.new_parking_spot = ParkingSpace.objects.create(parking_spot_id=1)
        id = parking_space_view._ParkingSpaceView__get_next_parkingspace_id()
        self.assertEqual(id, "2")

    def test_post_view(self):
        post_data = {
            "parking_spot_name": "TEST NAME",
            "type": "Street",
            "detail": "TEST DETAIL",
            "operation_hours": "TEST OP HRS",
            "occupancy_percent": 10,
        }
        # * Test without login
        response_without_logging_in = self.client.post(
            reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", post_data
        )
        self.assertEqual(response_without_logging_in.status_code, 404)

        # * Test with login but no lon and lat
        self.client.login(username=USERNAME, password=PASSWORD)
        with self.assertRaises(TypeError):
            response_no_lon_lat = self.client.post(reverse(ADD_SPOT_PATH_NAME))
            self.assertEqual(
                response_no_lon_lat.context.get("error"),
                "We failed to obtain the longitude and latitude of the new spot you want to create. Please double check your URL to include valid longitude and latitude",
            )

        # * Test with login and valid post_data
        response_with_valid_data = self.client.post(
            reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", post_data
        )
        self.assertTrue(CreateParkingSpaceForm(data=post_data).is_valid())
        self.assertEqual(ParkingSpace.objects.count(), 1)
        saved_parking_spot = ParkingSpace.objects.first()
        self.assertEqual(saved_parking_spot.parking_spot_id, "1")
        self.assertEqual(saved_parking_spot.longitude, "20.456")
        self.assertEqual(saved_parking_spot.latitude, "10.123")
        self.assertEqual(saved_parking_spot.user.id, self.user.id)
        self.assertEqual(response_with_valid_data.status_code, 200)
        self.assertIsNotNone(response_with_valid_data.context.get("user_verification"))

        # * Test with login and INVALID post_data
        invalid_post_data = {"parking_spot_name": "TEST NAME"}
        response_with_invalid_data = self.client.post(
            reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", invalid_post_data
        )
        self.assertFalse(CreateParkingSpaceForm(data=invalid_post_data).is_valid())
        self.assertIsNotNone(response_with_invalid_data.context.get("form"))


class ProfileSpotRedirectViewTests(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username=USERNAME, email=EMAIL, password=PASSWORD
        )
        self.test_spot = ParkingSpace.objects.create(
            parking_spot_id=PARKING_SPOT_ID,
            address_zip=ADDRESS_ZIP,
            longitude=LONGITUDE,
            latitude=LATITUDE,
            parking_spot_name=PARKING_SPOT_NAME,
        )

    def test_get_view(self):
        self.client.login(username=USERNAME, password=PASSWORD)
        response = self.client.get(
            reverse(REDIRECT_SPOT_PATH_NAME, args=[PARKING_SPOT_ID])
        )
        self.assertEqual(response.status_code, 200)
        self.assertIsNotNone(response.context.get("spot"))


class CreatePostTests(TestCase):
    def setUp(self):
        # Create a test user and test spot
        self.test_user = User.objects.create_user(
            username=USERNAME, email=EMAIL, password=PASSWORD
        )
        self.test_spot = ParkingSpace.objects.create(
            parking_spot_id=PARKING_SPOT_ID,
            address_zip=ADDRESS_ZIP,
            longitude=LONGITUDE,
            latitude=LATITUDE,
            parking_spot_name=PARKING_SPOT_NAME,
        )

    def test_post_view(self):
        """checks if post page returns a 200 status code
        and the template 'map/post.html' is used
        """
        self.client.login(username=USERNAME, password=PASSWORD)
        response = self.client.get(reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, POST_TEMPLATE)

    def test_successful_post(self):
        """checks if post is made successfully
        and redirects (Status 302) to Map Page
        """
        self.client.login(username=USERNAME, password=PASSWORD)
        post_data = {"title": TITLE, "post": POST, "created_at": DATE}
        response = self.client.post(
            reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]), post_data
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(Post.objects.filter(title=TITLE).exists())

    def test_unsuccessful_post_invalid_data(self):
        """check if user tries to submit empty post form"""
        self.client.login(username=USERNAME, password=PASSWORD)
        post_data = {"title": "", "post": "", "created_at": DATE}
        response = self.client.post(
            reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]), post_data
        )
        self.assertEqual(response.status_code, 200)
        self.assertFormError(response, "form", "title", "This field is required.")
        self.assertFormError(response, "form", "post", "This field is required.")

1	from django.test import TestCase	1✔
2	from django.urls import reverse	1✔
3	from django.utils import timezone	1✔
4
5	from users.models import User, Post, UserVerification	1✔
6	from .models import ParkingSpace	1✔
7	from .views import ParkingSpaceView	1✔
8	from .forms import CreateParkingSpaceForm	1✔
9
10
11	USERNAME = "parkrowd"	1✔
12	EMAIL = "parkrowd@gmail.com"	1✔
13	PASSWORD = "iLikeParking123!"	1✔
14	DUMMY_PASSWORD = "noParkingForYou"	1✔
15
16	PARKING_SPOT_ID = "12657"	1✔
17	ADDRESS_ZIP = "10001"	1✔
18	LONGITUDE = "-73.9853043125"	1✔
19	LATITUDE = "40.7486538125"	1✔
20	PARKING_SPOT_NAME = "Empire State Building"	1✔
21
22	TITLE = "Parking Here For 15 Minutes"	1✔
23	POST = "After 3:15, I'll be gone."	1✔
24	DATE = timezone.now()	1✔
25
26	POST_PATH_NAME = "map:post"	1✔
27	ADD_SPOT_PATH_NAME = "map:add-parking-space"	1✔
28	REDIRECT_SPOT_PATH_NAME = "map:spot-redirect"	1✔
29	MAP_PATH_NAME = "map:parking"	1✔
30	POST_TEMPLATE = "map/post.html"	1✔
31
32
33	class MapViewTests(TestCase):	1✔
34	def setUp(self):	1✔
35	self.user = User.objects.create_user(	1✔
36	username=USERNAME, email=EMAIL, password=PASSWORD
37	)
38	self.user_verification = UserVerification.objects.create(	1✔
39	username=self.user, status="verified"
40	)
41
42	def test_non_authenticated_user(self):	1✔
43	response = self.client.get(reverse(MAP_PATH_NAME))	1✔
44	self.assertEqual(response.status_code, 200)	1✔
45
46	# * Check if the user_verification is NOT present in the context
47	self.assertIsNone(response.context.get("user_verification"))	1✔
48
49	def test_authenticated_user(self):	1✔
50	self.client.login(username=USERNAME, password=PASSWORD)	1✔
51	response = self.client.get(reverse(MAP_PATH_NAME))	1✔
52	self.assertEqual(response.status_code, 200)	1✔
53
54	# * Check if the user_verification is present in the context
55	self.assertIsNotNone(response.context.get("user_verification"))	1✔
56
57
58	class ParkingSpaceViewTests(TestCase):	1✔
59	def setUp(self):	1✔
60	self.user = User.objects.create_user(	1✔
61	username=USERNAME, email=EMAIL, password=PASSWORD
62	)
63	self.user_verification = UserVerification.objects.create(	1✔
64	username=self.user, status="verified"
65	)
66
67	def test_get_view(self):	1✔
68	self.client.login(username=USERNAME, password=PASSWORD)	1✔
69	response_no_lat_lon = self.client.get(reverse(ADD_SPOT_PATH_NAME))	1✔
70	self.assertEqual(response_no_lat_lon.status_code, 200)	1✔
71	self.assertEqual(	1✔
72	response_no_lat_lon.context.get("error"),
73	"Unable to collect longitude and latitude from URL. Please check if the URL is correct.",
74	)
75	self.assertIsNotNone(response_no_lat_lon.context.get("user_verification"))	1✔
76
77	response_with_lat_lon = self.client.get(	1✔
78	reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456"
79	)
80	self.assertEqual(response_with_lat_lon.status_code, 200)	1✔
81	self.assertIsNone(response_with_lat_lon.context.get("error"))	1✔
82	self.assertIsNotNone(response_with_lat_lon.context.get("user_verification"))	1✔
83
84	def test_get_next_parking_space_id(self):	1✔
85	parking_space_view = ParkingSpaceView()	1✔
86	id = parking_space_view._ParkingSpaceView__get_next_parkingspace_id()	1✔
87	self.assertEqual(id, "1")	1✔
88
89	# * Test if adding new record generates new ID of 2
90	self.new_parking_spot = ParkingSpace.objects.create(parking_spot_id=1)	1✔
91	id = parking_space_view._ParkingSpaceView__get_next_parkingspace_id()	1✔
92	self.assertEqual(id, "2")	1✔
93
94	def test_post_view(self):	1✔
95	post_data = {	1✔
96	"parking_spot_name": "TEST NAME",
97	"type": "Street",
98	"detail": "TEST DETAIL",
99	"operation_hours": "TEST OP HRS",
100	"occupancy_percent": 10,
101	}
102	# * Test without login
103	response_without_logging_in = self.client.post(	1✔
104	reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", post_data
105	)
106	self.assertEqual(response_without_logging_in.status_code, 404)	1✔
107
108	# * Test with login but no lon and lat
109	self.client.login(username=USERNAME, password=PASSWORD)	1✔
110	with self.assertRaises(TypeError):	1✔
111	response_no_lon_lat = self.client.post(reverse(ADD_SPOT_PATH_NAME))	1✔
NEW 112	self.assertEqual(	×
113	response_no_lon_lat.context.get("error"),
114	"We failed to obtain the longitude and latitude of the new spot you want to create. Please double check your URL to include valid longitude and latitude",
115	)
116
117	# * Test with login and valid post_data
118	response_with_valid_data = self.client.post(	1✔
119	reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", post_data
120	)
121	self.assertTrue(CreateParkingSpaceForm(data=post_data).is_valid())	1✔
122	self.assertEqual(ParkingSpace.objects.count(), 1)	1✔
123	saved_parking_spot = ParkingSpace.objects.first()	1✔
124	self.assertEqual(saved_parking_spot.parking_spot_id, "1")	1✔
125	self.assertEqual(saved_parking_spot.longitude, "20.456")	1✔
126	self.assertEqual(saved_parking_spot.latitude, "10.123")	1✔
127	self.assertEqual(saved_parking_spot.user.id, self.user.id)	1✔
128	self.assertEqual(response_with_valid_data.status_code, 200)	1✔
129	self.assertIsNotNone(response_with_valid_data.context.get("user_verification"))	1✔
130
131	# * Test with login and INVALID post_data
132	invalid_post_data = {"parking_spot_name": "TEST NAME"}	1✔
133	response_with_invalid_data = self.client.post(	1✔
134	reverse(ADD_SPOT_PATH_NAME) + "?lat=10.123&lon=20.456", invalid_post_data
135	)
136	self.assertFalse(CreateParkingSpaceForm(data=invalid_post_data).is_valid())	1✔
137	self.assertIsNotNone(response_with_invalid_data.context.get("form"))	1✔
138
139
140	class ProfileSpotRedirectViewTests(TestCase):	1✔
141	def setUp(self):	1✔
142	self.user = User.objects.create_user(	1✔
143	username=USERNAME, email=EMAIL, password=PASSWORD
144	)
145	self.test_spot = ParkingSpace.objects.create(	1✔
146	parking_spot_id=PARKING_SPOT_ID,
147	address_zip=ADDRESS_ZIP,
148	longitude=LONGITUDE,
149	latitude=LATITUDE,
150	parking_spot_name=PARKING_SPOT_NAME,
151	)
152
153	def test_get_view(self):	1✔
154	self.client.login(username=USERNAME, password=PASSWORD)	1✔
155	response = self.client.get(	1✔
156	reverse(REDIRECT_SPOT_PATH_NAME, args=[PARKING_SPOT_ID])
157	)
158	self.assertEqual(response.status_code, 200)	1✔
159	self.assertIsNotNone(response.context.get("spot"))	1✔
160
161
162	class CreatePostTests(TestCase):	1✔
163	def setUp(self):	1✔
164	# Create a test user and test spot
165	self.test_user = User.objects.create_user(	1✔
166	username=USERNAME, email=EMAIL, password=PASSWORD
167	)
168	self.test_spot = ParkingSpace.objects.create(	1✔
169	parking_spot_id=PARKING_SPOT_ID,
170	address_zip=ADDRESS_ZIP,
171	longitude=LONGITUDE,
172	latitude=LATITUDE,
173	parking_spot_name=PARKING_SPOT_NAME,
174	)
175
176	def test_post_view(self):	1✔
177	"""checks if post page returns a 200 status code
178	and the template 'map/post.html' is used
179	"""
180	self.client.login(username=USERNAME, password=PASSWORD)	1✔
181	response = self.client.get(reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]))	1✔
182	self.assertEqual(response.status_code, 200)	1✔
183	self.assertTemplateUsed(response, POST_TEMPLATE)	1✔
184
185	def test_successful_post(self):	1✔
186	"""checks if post is made successfully
187	and redirects (Status 302) to Map Page
188	"""
189	self.client.login(username=USERNAME, password=PASSWORD)	1✔
190	post_data = {"title": TITLE, "post": POST, "created_at": DATE}	1✔
191	response = self.client.post(	1✔
192	reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]), post_data
193	)
194	self.assertEqual(response.status_code, 200)	1✔
195	self.assertTrue(Post.objects.filter(title=TITLE).exists())	1✔
196
197	def test_unsuccessful_post_invalid_data(self):	1✔
198	"""check if user tries to submit empty post form"""
199	self.client.login(username=USERNAME, password=PASSWORD)	1✔
200	post_data = {"title": "", "post": "", "created_at": DATE}	1✔
201	response = self.client.post(	1✔
202	reverse(POST_PATH_NAME, args=[PARKING_SPOT_ID]), post_data
203	)
204	self.assertEqual(response.status_code, 200)	1✔
205	self.assertFormError(response, "form", "title", "This field is required.")	1✔
206	self.assertFormError(response, "form", "post", "This field is required.")	1✔

gcivil-nyu-org / Wednesday-Fall2023-Team-2 / #614972427

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