gcivil-nyu-org / INT2-Monday-Spring2024-Team-2 / 497

Committed 25 Mar 2024 10:26PM UTC coverage: 90.028% (-3.4%) from 93.396%

Build # 497

Build Type

cron

travis-pro

Committed by

web-flow

Commit Message

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

merge dev to master

Run Details

257 of 410 new or added lines in 15 files covered. (62.68%)

78 existing lines in 5 files now uncovered.

957 of 1063 relevant lines covered (90.03%)

1.65 hits per line

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

100.0

/TutorRegister/forms/test_forms.py

from django.test import TestCase
from django.contrib.auth.models import User
from TutorRegister.forms.register_login import RegisterUserForm
from TutorRegister.forms.student_info import StudentForm
from TutorRegister.models import ProfileS


class RegisterUserFormTest(TestCase):
    def setUp(self):
        User.objects.create_user(
            username="existinguser@example.com",
            email="existinguser@example.com",
            password="12345",
        )

    def test_form_valid(self):
        form_data = {
            "user_type": "student",
            "email": "newuser@example.com",
            "first_name": "John",
            "last_name": "Doe",
            "password1": "Password123...",
            "password2": "Password123...",
        }
        form = RegisterUserForm(data=form_data)
        self.assertTrue(form.is_valid())

    def test_form_invalid_email_exists(self):
        form_data = {
            "user_type": "student",
            "email": "existinguser@example.com",
            "first_name": "John",
            "last_name": "Doe",
            "password1": "password123",
            "password2": "password123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)
        self.assertEqual(
            form.errors["email"], ["A user with that email already exists."]
        )

    def test_form_invalid_tutor_email(self):
        form_data = {
            "user_type": "tutor",
            "email": "tutor@example.com",
            "first_name": "John",
            "last_name": "Doe",
            "password1": "password123",
            "password2": "password123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)
        self.assertEqual(
            form.errors["email"], ["Tutor email address must end with '@nyu.edu'."]
        )

    def test_form_empty_first_name(self):
        form_data = {
            "user_type": "student",
            "email": "newuser@example.com",
            "first_name": "",
            "last_name": "Doe",
            "password1": "password123",
            "password2": "password123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("first_name", form.errors)
        self.assertEqual(
            form.errors["first_name"],
            ["This field is required.", "First name cannot be empty."],
        )

    def test_form_empty_last_name(self):
        form_data = {
            "user_type": "student",
            "email": "newuser@example.com",
            "first_name": "John",
            "last_name": "",
            "password1": "password123",
            "password2": "password123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("last_name", form.errors)
        self.assertEqual(
            form.errors["last_name"],
            ["This field is required.", "Last name cannot be empty."],
        )

    def test_save_new_user(self):
        form_data = {
            "user_type": "student",
            "email": "test@example.com",
            "first_name": "John",
            "last_name": "Doe",
            "password1": "Testpassword123",
            "password2": "Testpassword123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertTrue(form.is_valid())

        user = form.save()
        self.assertIsInstance(user, User)
        self.assertEqual(user.username, form_data["email"])
        self.assertEqual(user.first_name, form_data["first_name"])
        self.assertEqual(user.last_name, form_data["last_name"])
        self.assertTrue(user.check_password(form_data["password1"]))

    def test_save_existing_user(self):
        User.objects.create_user(
            username="existing@example.com", password="Testpassword123"
        )
        form_data = {
            "user_type": "student",
            "email": "existing@example.com",
            "first_name": "John",
            "last_name": "Doe",
            "password1": "Testpassword123",
            "password2": "Testpassword123",
        }
        form = RegisterUserForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)


class StudentFormTestCase(TestCase):
    def test_student_form_valid_data(self):
        form = StudentForm(
            data={
                "fname": "John",
                "lname": "Doe",
                "gender": "male",
                "zip": "12345",
                "school": "ABC High School",
                "grade": "10",
                "preferred_mode": "inperson",
                "intro": "I am a 10th-grade student.",
            }
        )
        self.assertTrue(form.is_valid())

    def test_student_form_invalid_data(self):
        form = StudentForm(data={})
        self.assertFalse(form.is_valid())
        self.assertEqual(len(form.errors), 8)  # Assuming all fields are required

    def test_student_form_gender_choices(self):
        form = StudentForm()
        self.assertEqual(
            form.fields["gender"].choices,
            [
                ("female", "Female"),
                ("male", "Male"),
                ("prefernottosay", "Prefer not to say"),
            ],
        )

    def test_student_form_grade_choices(self):
        form = StudentForm()
        self.assertEqual(
            form.fields["grade"].choices,
            [
                ("1", "1st Grade"),
                ("2", "2nd Grade"),
                ("3", "3rd Grade"),
                ("4", "4th Grade"),
                ("5", "5th Grade"),
                ("6", "6th Grade"),
                ("7", "7th Grade"),
                ("8", "8th Grade"),
                ("9", "9th Grade"),
                ("10", "10th Grade"),
                ("11", "11th Grade"),
                ("12", "12th Grade"),
                ("undergrad", "Undergraduate"),
                ("grad", "Graduate"),
                ("postgrad", "Post-graduate"),
            ],
        )

    def test_student_form_preferred_mode_choices(self):
        form = StudentForm()
        self.assertEqual(
            form.fields["preferred_mode"].choices,
            [
                ("inperson", "In-person"),
                ("remote", "Remote"),
                ("both", "Both"),
            ],
        )

    def test_student_form_empty_fields(self):
        form = StudentForm(
            data={
                "fname": "",
                "lname": "",
                "gender": "",
                "zip": "",
                "school": "",
                "grade": "",
                "preferred_mode": "",
                "intro": "",
            }
        )
        self.assertFalse(form.is_valid())
        self.assertEqual(len(form.errors), 8)

1	from django.test import TestCase	2✔
2	from django.contrib.auth.models import User	2✔
3	from TutorRegister.forms.register_login import RegisterUserForm	2✔
4	from TutorRegister.forms.student_info import StudentForm	2✔
5	from TutorRegister.models import ProfileS	2✔
6
7
8	class RegisterUserFormTest(TestCase):	2✔
9	def setUp(self):	2✔
10	User.objects.create_user(	2✔
11	username="existinguser@example.com",
12	email="existinguser@example.com",
13	password="12345",
14	)
15
16	def test_form_valid(self):	2✔
17	form_data = {	2✔
18	"user_type": "student",
19	"email": "newuser@example.com",
20	"first_name": "John",
21	"last_name": "Doe",
22	"password1": "Password123...",
23	"password2": "Password123...",
24	}
25	form = RegisterUserForm(data=form_data)	2✔
26	self.assertTrue(form.is_valid())	2✔
27
28	def test_form_invalid_email_exists(self):	2✔
29	form_data = {	2✔
30	"user_type": "student",
31	"email": "existinguser@example.com",
32	"first_name": "John",
33	"last_name": "Doe",
34	"password1": "password123",
35	"password2": "password123",
36	}
37	form = RegisterUserForm(data=form_data)	2✔
38	self.assertFalse(form.is_valid())	2✔
39	self.assertIn("email", form.errors)	2✔
40	self.assertEqual(	2✔
41	form.errors["email"], ["A user with that email already exists."]
42	)
43
44	def test_form_invalid_tutor_email(self):	2✔
45	form_data = {	2✔
46	"user_type": "tutor",
47	"email": "tutor@example.com",
48	"first_name": "John",
49	"last_name": "Doe",
50	"password1": "password123",
51	"password2": "password123",
52	}
53	form = RegisterUserForm(data=form_data)	2✔
54	self.assertFalse(form.is_valid())	2✔
55	self.assertIn("email", form.errors)	2✔
56	self.assertEqual(	2✔
57	form.errors["email"], ["Tutor email address must end with '@nyu.edu'."]
58	)
59
60	def test_form_empty_first_name(self):	2✔
61	form_data = {	2✔
62	"user_type": "student",
63	"email": "newuser@example.com",
64	"first_name": "",
65	"last_name": "Doe",
66	"password1": "password123",
67	"password2": "password123",
68	}
69	form = RegisterUserForm(data=form_data)	2✔
70	self.assertFalse(form.is_valid())	2✔
71	self.assertIn("first_name", form.errors)	2✔
72	self.assertEqual(	2✔
73	form.errors["first_name"],
74	["This field is required.", "First name cannot be empty."],
75	)
76
77	def test_form_empty_last_name(self):	2✔
78	form_data = {	2✔
79	"user_type": "student",
80	"email": "newuser@example.com",
81	"first_name": "John",
82	"last_name": "",
83	"password1": "password123",
84	"password2": "password123",
85	}
86	form = RegisterUserForm(data=form_data)	2✔
87	self.assertFalse(form.is_valid())	2✔
88	self.assertIn("last_name", form.errors)	2✔
89	self.assertEqual(	2✔
90	form.errors["last_name"],
91	["This field is required.", "Last name cannot be empty."],
92	)
93
94	def test_save_new_user(self):	2✔
95	form_data = {	2✔
96	"user_type": "student",
97	"email": "test@example.com",
98	"first_name": "John",
99	"last_name": "Doe",
100	"password1": "Testpassword123",
101	"password2": "Testpassword123",
102	}
103	form = RegisterUserForm(data=form_data)	2✔
104	self.assertTrue(form.is_valid())	2✔
105
UNCOV 106	user = form.save()	1✔
UNCOV 107	self.assertIsInstance(user, User)	1✔
UNCOV 108	self.assertEqual(user.username, form_data["email"])	1✔
UNCOV 109	self.assertEqual(user.first_name, form_data["first_name"])	1✔
UNCOV 110	self.assertEqual(user.last_name, form_data["last_name"])	1✔
UNCOV 111	self.assertTrue(user.check_password(form_data["password1"]))	1✔
112
113	def test_save_existing_user(self):	2✔
114	User.objects.create_user(	2✔
115	username="existing@example.com", password="Testpassword123"
116	)
117	form_data = {	2✔
118	"user_type": "student",
119	"email": "existing@example.com",
120	"first_name": "John",
121	"last_name": "Doe",
122	"password1": "Testpassword123",
123	"password2": "Testpassword123",
124	}
125	form = RegisterUserForm(data=form_data)	2✔
126	self.assertFalse(form.is_valid())	2✔
127	self.assertIn("email", form.errors)	2✔
128
129
130	class StudentFormTestCase(TestCase):	2✔
131	def test_student_form_valid_data(self):	2✔
132	form = StudentForm(	2✔
133	data={
134	"fname": "John",
135	"lname": "Doe",
136	"gender": "male",
137	"zip": "12345",
138	"school": "ABC High School",
139	"grade": "10",
140	"preferred_mode": "inperson",
141	"intro": "I am a 10th-grade student.",
142	}
143	)
144	self.assertTrue(form.is_valid())	2✔
145
146	def test_student_form_invalid_data(self):	2✔
147	form = StudentForm(data={})	2✔
148	self.assertFalse(form.is_valid())	2✔
149	self.assertEqual(len(form.errors), 8) # Assuming all fields are required	2✔
150
151	def test_student_form_gender_choices(self):	2✔
152	form = StudentForm()	2✔
153	self.assertEqual(	2✔
154	form.fields["gender"].choices,
155	[
156	("female", "Female"),
157	("male", "Male"),
158	("prefernottosay", "Prefer not to say"),
159	],
160	)
161
162	def test_student_form_grade_choices(self):	2✔
163	form = StudentForm()	2✔
164	self.assertEqual(	2✔
165	form.fields["grade"].choices,
166	[
167	("1", "1st Grade"),
168	("2", "2nd Grade"),
169	("3", "3rd Grade"),
170	("4", "4th Grade"),
171	("5", "5th Grade"),
172	("6", "6th Grade"),
173	("7", "7th Grade"),
174	("8", "8th Grade"),
175	("9", "9th Grade"),
176	("10", "10th Grade"),
177	("11", "11th Grade"),
178	("12", "12th Grade"),
179	("undergrad", "Undergraduate"),
180	("grad", "Graduate"),
181	("postgrad", "Post-graduate"),
182	],
183	)
184
185	def test_student_form_preferred_mode_choices(self):	2✔
186	form = StudentForm()	2✔
187	self.assertEqual(	2✔
188	form.fields["preferred_mode"].choices,
189	[
190	("inperson", "In-person"),
191	("remote", "Remote"),
192	("both", "Both"),
193	],
194	)
195
196	def test_student_form_empty_fields(self):	2✔
197	form = StudentForm(	2✔
198	data={
199	"fname": "",
200	"lname": "",
201	"gender": "",
202	"zip": "",
203	"school": "",
204	"grade": "",
205	"preferred_mode": "",
206	"intro": "",
207	}
208	)
209	self.assertFalse(form.is_valid())	2✔
210	self.assertEqual(len(form.errors), 8)	2✔

gcivil-nyu-org / INT2-Monday-Spring2024-Team-2 / 497

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