gcivil-nyu-org / Wednesday-Fall2023-Team-6 / 281

Committed 08 Nov 2023 08:37PM UTC coverage: 96.16%. First build

Build # 281

Build Type

Pull #147

travis-pro

Committed by

Chinnu1103

Commit Message

bucket name

Pull Request Pull Request #147: Pre master - Check

Run Details

1277 of 1328 new or added lines in 64 files covered. (96.16%)

1277 of 1328 relevant lines covered (96.16%)

0.96 hits per line

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

98.02

/user/tests/tests_registration.py

from django.test import TestCase
from django.contrib.auth.models import User
from django.contrib import auth
from django.contrib.messages import get_messages, constants
from user.models import Patient
from doctor.models import Doctor
from hospital.models import HospitalAdmin, Hospital

from MediLink.settings import MESSAGE_TAGS


class RegistrationTests(TestCase):
    @classmethod
    def setUpClass(self):
        # Create Patient
        self.patient_user_email = "test_patient_user@gmail.com"
        self.user_password = "test_password"

        # Create Doctor
        self.doctor_user_email = "test_doctor_user@gmail.com"

        # Create Hospital Admin
        self.admin_user_email = "test_admin_user@gmail.com"

        self.hosiptal = Hospital.objects.create(
            name="Test",
            facility_type="Test",
            borough="Test",
            phone="34536",
            location="Test",
            postal_code=12345,
        )

        self.post_data_patient = {
            "user_email": self.patient_user_email,
            "user_name": "Patient",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "5002001000",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
            "insurance": "NYU Insurance",
        }

        self.post_data_doctor = {
            "user_email": self.doctor_user_email,
            "user_name": "Doctor",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "5002001000",
            "userType": "doctor",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
            "specialization": "Pediatrician",
            "hospital": "",
        }

        self.post_data_hospital = {
            "user_email": self.admin_user_email,
            "user_name": "Hospital",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "5002001000",
            "userType": "hospital-admin",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
            "hospital": self.hosiptal.id,
        }

        User.objects.create_user(
            self.patient_user_email, self.patient_user_email, self.user_password
        )
        User.objects.create_user(
            self.doctor_user_email, self.doctor_user_email, self.user_password
        )
        User.objects.create_user(
            self.admin_user_email, self.admin_user_email, self.user_password
        )

    def test_01_nonexisting_user(self):
        print("\nRunning: test for checking registration of nonexisting user")

        response = self.client.get("/user/registration/")
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "user/user_registration.html")

        post_data_users = [
            dict(self.post_data_patient),
            dict(self.post_data_doctor),
            dict(self.post_data_hospital),
        ]

        for post_data in post_data_users:
            post_data["user_email"] += ".in"  # So that user is new and non-existing
            response = self.client.post("/user/registration/", post_data)
            messages = list(get_messages(response.wsgi_request))
            if len(messages) > 0:
                print("Error Message::")
                print(messages[0].message)

            self.assertTrue(User.objects.filter(email=post_data["user_email"]).exists())
            if post_data["userType"] == "patient":
                self.assertTrue(
                    Patient.objects.filter(email=post_data["user_email"]).exists()
                )
                user = Patient.objects.get(email=post_data["user_email"])
            elif post_data["userType"] == "doctor":
                self.assertTrue(
                    Doctor.objects.filter(email=post_data["user_email"]).exists()
                )
                user = Doctor.objects.get(email=post_data["user_email"])
            else:
                self.assertTrue(
                    HospitalAdmin.objects.filter(email=post_data["user_email"]).exists()
                )
                user = HospitalAdmin.objects.get(email=post_data["user_email"])

            self.assertEqual(user.name, post_data["user_name"])
            self.assertEqual(user.sex.lower(), str(post_data["user_sex"]).lower())
            self.assertEqual(user.phone, post_data["user_phone"])

            self.assertEqual(user.borough, post_data["borough"])
            self.assertEqual(user.address, post_data["address"])
            self.assertEqual(user.zip, post_data["zip"])

            if post_data["userType"] == "patient":
                self.assertEqual(user.insurance_provider, post_data["insurance"])
            elif post_data["userType"] == "doctor":
                self.assertEqual(user.primary_speciality, post_data["specialization"])
                self.assertEqual(user.associated_hospital, None)
            else:
                self.assertEqual(user.associated_hospital.id, post_data["hospital"])

            logged_in_user = auth.get_user(self.client)
            self.assertEqual(logged_in_user.get_username(), post_data["user_email"])
            self.assertTrue(logged_in_user.is_authenticated)
            self.assertRedirects(
                response=response,
                expected_url="/user/home/",
                status_code=302,
                target_status_code=200,
            )
            self.client.logout()

        # Replace with our logout call later
        print("Completed: test for checking login of nonexisting user")

    def test_02_existing_user_all_data(self):
        print("\nRunning: test for checking registration of existing users")

        post_data_users = [
            self.post_data_patient,
            self.post_data_doctor,
            self.post_data_hospital,
        ]

        for post_data in post_data_users:
            response = self.client.post("/user/registration/", post_data)
            logged_in_user = auth.get_user(self.client)
            self.assertNotEqual(logged_in_user.get_username(), post_data["user_email"])
            self.assertFalse(logged_in_user.is_authenticated)
            messages = list(get_messages(response.wsgi_request))
            self.assertEqual(len(messages), 1)
            self.assertEqual(messages[0].tags, MESSAGE_TAGS[constants.ERROR])
            self.assertRedirects(
                response=response,
                expected_url="/user/registration/",
                status_code=302,
                target_status_code=200,
            )

        # Replace with our logout call later
        print("Completed: test for checking registration of existing users")

    def test_03_nonexisting_user_incorrect_data(self):
        print("\nRunning: test for checking registration of incorrect users")
        post_invalid_email = {
            "user_email": "invalid",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_name = {
            "user_email": "valid@gmail.com",
            "user_name": "",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_password = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": "",
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_sex = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "gmale",
            "user_phone": "1234567890",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_phone = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_type = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "none",
            "address": "73rd Street",
            "borough": "BKN",
            "zip": 11209,
        }

        post_invalid_borough = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "patient",
            "address": "73rd Street",
            "borough": "Brooklyn",
            "zip": 11209,
            "specialization": "Pediatrician",
        }

        post_invalid_hospital = {
            "user_email": "valid@gmail.com",
            "user_name": "Name LName",
            "password": self.user_password,
            "user_sex": "male",
            "user_phone": "1234567890",
            "userType": "hospital-admin",
            "address": "73rd Street",
            "borough": "Brooklyn",
            "zip": 11209,
            "hospital": "",
        }

        post_data_users = [
            post_invalid_email,
            post_invalid_name,
            post_invalid_password,
            post_invalid_sex,
            post_invalid_phone,
            post_invalid_type,
            post_invalid_borough,
            post_invalid_hospital,
        ]

        for post_data in post_data_users:
            response = self.client.post("/user/registration/", post_data)
            logged_in_user = auth.get_user(self.client)
            self.assertNotEqual(logged_in_user.get_username(), post_data["user_email"])
            self.assertFalse(logged_in_user.is_authenticated)
            messages = list(get_messages(response.wsgi_request))
            self.assertEqual(len(messages), 1)
            self.assertEqual(messages[0].tags, MESSAGE_TAGS[constants.ERROR])
            self.assertRedirects(
                response=response,
                expected_url="/user/registration/",
                status_code=302,
                target_status_code=200,
            )

        # Replace with our logout call later
        print("Completed: test for checking registration of incorrect users")

    def tearDown(self):
        self.client.logout()

    @classmethod
    def tearDownClass(self):
        self.hosiptal.delete()

1	from django.test import TestCase	1✔
2	from django.contrib.auth.models import User	1✔
3	from django.contrib import auth	1✔
4	from django.contrib.messages import get_messages, constants	1✔
5	from user.models import Patient	1✔
6	from doctor.models import Doctor	1✔
7	from hospital.models import HospitalAdmin, Hospital	1✔
8
9	from MediLink.settings import MESSAGE_TAGS	1✔
10
11
12	class RegistrationTests(TestCase):	1✔
13	@classmethod	1✔
14	def setUpClass(self):	1✔
15	# Create Patient
16	self.patient_user_email = "test_patient_user@gmail.com"	1✔
17	self.user_password = "test_password"	1✔
18
19	# Create Doctor
20	self.doctor_user_email = "test_doctor_user@gmail.com"	1✔
21
22	# Create Hospital Admin
23	self.admin_user_email = "test_admin_user@gmail.com"	1✔
24
25	self.hosiptal = Hospital.objects.create(	1✔
26	name="Test",
27	facility_type="Test",
28	borough="Test",
29	phone="34536",
30	location="Test",
31	postal_code=12345,
32	)
33
34	self.post_data_patient = {	1✔
35	"user_email": self.patient_user_email,
36	"user_name": "Patient",
37	"password": self.user_password,
38	"user_sex": "male",
39	"user_phone": "5002001000",
40	"userType": "patient",
41	"address": "73rd Street",
42	"borough": "BKN",
43	"zip": 11209,
44	"insurance": "NYU Insurance",
45	}
46
47	self.post_data_doctor = {	1✔
48	"user_email": self.doctor_user_email,
49	"user_name": "Doctor",
50	"password": self.user_password,
51	"user_sex": "male",
52	"user_phone": "5002001000",
53	"userType": "doctor",
54	"address": "73rd Street",
55	"borough": "BKN",
56	"zip": 11209,
57	"specialization": "Pediatrician",
58	"hospital": "",
59	}
60
61	self.post_data_hospital = {	1✔
62	"user_email": self.admin_user_email,
63	"user_name": "Hospital",
64	"password": self.user_password,
65	"user_sex": "male",
66	"user_phone": "5002001000",
67	"userType": "hospital-admin",
68	"address": "73rd Street",
69	"borough": "BKN",
70	"zip": 11209,
71	"hospital": self.hosiptal.id,
72	}
73
74	User.objects.create_user(	1✔
75	self.patient_user_email, self.patient_user_email, self.user_password
76	)
77	User.objects.create_user(	1✔
78	self.doctor_user_email, self.doctor_user_email, self.user_password
79	)
80	User.objects.create_user(	1✔
81	self.admin_user_email, self.admin_user_email, self.user_password
82	)
83
84	def test_01_nonexisting_user(self):	1✔
85	print("\nRunning: test for checking registration of nonexisting user")	1✔
86
87	response = self.client.get("/user/registration/")	1✔
88	self.assertEqual(response.status_code, 200)	1✔
89	self.assertTemplateUsed(response, "user/user_registration.html")	1✔
90
91	post_data_users = [	1✔
92	dict(self.post_data_patient),
93	dict(self.post_data_doctor),
94	dict(self.post_data_hospital),
95	]
96
97	for post_data in post_data_users:	1✔
98	post_data["user_email"] += ".in" # So that user is new and non-existing	1✔
99	response = self.client.post("/user/registration/", post_data)	1✔
100	messages = list(get_messages(response.wsgi_request))	1✔
101	if len(messages) > 0:	1✔
NEW 102	print("Error Message::")	×
NEW 103	print(messages[0].message)	×
104
105	self.assertTrue(User.objects.filter(email=post_data["user_email"]).exists())	1✔
106	if post_data["userType"] == "patient":	1✔
107	self.assertTrue(	1✔
108	Patient.objects.filter(email=post_data["user_email"]).exists()
109	)
110	user = Patient.objects.get(email=post_data["user_email"])	1✔
111	elif post_data["userType"] == "doctor":	1✔
112	self.assertTrue(	1✔
113	Doctor.objects.filter(email=post_data["user_email"]).exists()
114	)
115	user = Doctor.objects.get(email=post_data["user_email"])	1✔
116	else:
117	self.assertTrue(	1✔
118	HospitalAdmin.objects.filter(email=post_data["user_email"]).exists()
119	)
120	user = HospitalAdmin.objects.get(email=post_data["user_email"])	1✔
121
122	self.assertEqual(user.name, post_data["user_name"])	1✔
123	self.assertEqual(user.sex.lower(), str(post_data["user_sex"]).lower())	1✔
124	self.assertEqual(user.phone, post_data["user_phone"])	1✔
125
126	self.assertEqual(user.borough, post_data["borough"])	1✔
127	self.assertEqual(user.address, post_data["address"])	1✔
128	self.assertEqual(user.zip, post_data["zip"])	1✔
129
130	if post_data["userType"] == "patient":	1✔
131	self.assertEqual(user.insurance_provider, post_data["insurance"])	1✔
132	elif post_data["userType"] == "doctor":	1✔
133	self.assertEqual(user.primary_speciality, post_data["specialization"])	1✔
134	self.assertEqual(user.associated_hospital, None)	1✔
135	else:
136	self.assertEqual(user.associated_hospital.id, post_data["hospital"])	1✔
137
138	logged_in_user = auth.get_user(self.client)	1✔
139	self.assertEqual(logged_in_user.get_username(), post_data["user_email"])	1✔
140	self.assertTrue(logged_in_user.is_authenticated)	1✔
141	self.assertRedirects(	1✔
142	response=response,
143	expected_url="/user/home/",
144	status_code=302,
145	target_status_code=200,
146	)
147	self.client.logout()	1✔
148
149	# Replace with our logout call later
150	print("Completed: test for checking login of nonexisting user")	1✔
151
152	def test_02_existing_user_all_data(self):	1✔
153	print("\nRunning: test for checking registration of existing users")	1✔
154
155	post_data_users = [	1✔
156	self.post_data_patient,
157	self.post_data_doctor,
158	self.post_data_hospital,
159	]
160
161	for post_data in post_data_users:	1✔
162	response = self.client.post("/user/registration/", post_data)	1✔
163	logged_in_user = auth.get_user(self.client)	1✔
164	self.assertNotEqual(logged_in_user.get_username(), post_data["user_email"])	1✔
165	self.assertFalse(logged_in_user.is_authenticated)	1✔
166	messages = list(get_messages(response.wsgi_request))	1✔
167	self.assertEqual(len(messages), 1)	1✔
168	self.assertEqual(messages[0].tags, MESSAGE_TAGS[constants.ERROR])	1✔
169	self.assertRedirects(	1✔
170	response=response,
171	expected_url="/user/registration/",
172	status_code=302,
173	target_status_code=200,
174	)
175
176	# Replace with our logout call later
177	print("Completed: test for checking registration of existing users")	1✔
178
179	def test_03_nonexisting_user_incorrect_data(self):	1✔
180	print("\nRunning: test for checking registration of incorrect users")	1✔
181	post_invalid_email = {	1✔
182	"user_email": "invalid",
183	"user_name": "Name LName",
184	"password": self.user_password,
185	"user_sex": "male",
186	"user_phone": "1234567890",
187	"userType": "patient",
188	"address": "73rd Street",
189	"borough": "BKN",
190	"zip": 11209,
191	}
192
193	post_invalid_name = {	1✔
194	"user_email": "valid@gmail.com",
195	"user_name": "",
196	"password": self.user_password,
197	"user_sex": "male",
198	"user_phone": "1234567890",
199	"userType": "patient",
200	"address": "73rd Street",
201	"borough": "BKN",
202	"zip": 11209,
203	}
204
205	post_invalid_password = {	1✔
206	"user_email": "valid@gmail.com",
207	"user_name": "Name LName",
208	"password": "",
209	"user_sex": "male",
210	"user_phone": "1234567890",
211	"userType": "patient",
212	"address": "73rd Street",
213	"borough": "BKN",
214	"zip": 11209,
215	}
216
217	post_invalid_sex = {	1✔
218	"user_email": "valid@gmail.com",
219	"user_name": "Name LName",
220	"password": self.user_password,
221	"user_sex": "gmale",
222	"user_phone": "1234567890",
223	"userType": "patient",
224	"address": "73rd Street",
225	"borough": "BKN",
226	"zip": 11209,
227	}
228
229	post_invalid_phone = {	1✔
230	"user_email": "valid@gmail.com",
231	"user_name": "Name LName",
232	"password": self.user_password,
233	"user_sex": "male",
234	"user_phone": "",
235	"userType": "patient",
236	"address": "73rd Street",
237	"borough": "BKN",
238	"zip": 11209,
239	}
240
241	post_invalid_type = {	1✔
242	"user_email": "valid@gmail.com",
243	"user_name": "Name LName",
244	"password": self.user_password,
245	"user_sex": "male",
246	"user_phone": "1234567890",
247	"userType": "none",
248	"address": "73rd Street",
249	"borough": "BKN",
250	"zip": 11209,
251	}
252
253	post_invalid_borough = {	1✔
254	"user_email": "valid@gmail.com",
255	"user_name": "Name LName",
256	"password": self.user_password,
257	"user_sex": "male",
258	"user_phone": "1234567890",
259	"userType": "patient",
260	"address": "73rd Street",
261	"borough": "Brooklyn",
262	"zip": 11209,
263	"specialization": "Pediatrician",
264	}
265
266	post_invalid_hospital = {	1✔
267	"user_email": "valid@gmail.com",
268	"user_name": "Name LName",
269	"password": self.user_password,
270	"user_sex": "male",
271	"user_phone": "1234567890",
272	"userType": "hospital-admin",
273	"address": "73rd Street",
274	"borough": "Brooklyn",
275	"zip": 11209,
276	"hospital": "",
277	}
278
279	post_data_users = [	1✔
280	post_invalid_email,
281	post_invalid_name,
282	post_invalid_password,
283	post_invalid_sex,
284	post_invalid_phone,
285	post_invalid_type,
286	post_invalid_borough,
287	post_invalid_hospital,
288	]
289
290	for post_data in post_data_users:	1✔
291	response = self.client.post("/user/registration/", post_data)	1✔
292	logged_in_user = auth.get_user(self.client)	1✔
293	self.assertNotEqual(logged_in_user.get_username(), post_data["user_email"])	1✔
294	self.assertFalse(logged_in_user.is_authenticated)	1✔
295	messages = list(get_messages(response.wsgi_request))	1✔
296	self.assertEqual(len(messages), 1)	1✔
297	self.assertEqual(messages[0].tags, MESSAGE_TAGS[constants.ERROR])	1✔
298	self.assertRedirects(	1✔
299	response=response,
300	expected_url="/user/registration/",
301	status_code=302,
302	target_status_code=200,
303	)
304
305	# Replace with our logout call later
306	print("Completed: test for checking registration of incorrect users")	1✔
307
308	def tearDown(self):	1✔
309	self.client.logout()	1✔
310
311	@classmethod	1✔
312	def tearDownClass(self):	1✔
313	self.hosiptal.delete()	1✔

gcivil-nyu-org / Wednesday-Fall2023-Team-6 / 281

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