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

Committed 04 May 2024 03:36PM UTC coverage: 91.716%. Remained the same

Build # 809

Build Type

Pull #253

travis-pro

Committed by

web-flow

Commit Message

Merge 26fc3c1b5 into 48120f46f

Pull Request Pull Request #253: Survey

Run Details

2015 of 2197 relevant lines covered (91.72%)

1.37 hits per line

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

100.0

/TutorRegister/tests/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": "newuser@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(	1✔
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 = {	1✔
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)	1✔
26	self.assertTrue(form.is_valid())	1✔
27
28	def test_form_invalid_email_exists(self):	2✔
29	form_data = {	1✔
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)	1✔
38	self.assertFalse(form.is_valid())	1✔
39	self.assertIn("email", form.errors)	1✔
40	self.assertEqual(	1✔
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 = {	1✔
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)	1✔
54	self.assertFalse(form.is_valid())	1✔
55	self.assertIn("email", form.errors)	1✔
56	self.assertEqual(	1✔
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 = {	1✔
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)	1✔
70	self.assertFalse(form.is_valid())	1✔
71	self.assertIn("first_name", form.errors)	1✔
72	self.assertEqual(	1✔
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 = {	1✔
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)	1✔
87	self.assertFalse(form.is_valid())	1✔
88	self.assertIn("last_name", form.errors)	1✔
89	self.assertEqual(	1✔
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 = {	1✔
96	"user_type": "student",
97	"email": "newuser@example.com",
98	"first_name": "John",
99	"last_name": "Doe",
100	"password1": "Testpassword123",
101	"password2": "Testpassword123",
102	}
103	form = RegisterUserForm(data=form_data)	1✔
104	self.assertTrue(form.is_valid())	1✔
105
106	user = form.save()	1✔
107	self.assertIsInstance(user, User)	1✔
108	self.assertEqual(user.username, form_data["email"])	1✔
109	self.assertEqual(user.first_name, form_data["first_name"])	1✔
110	self.assertEqual(user.last_name, form_data["last_name"])	1✔
111	self.assertTrue(user.check_password(form_data["password1"]))	1✔
112
113	def test_save_existing_user(self):	2✔
114	User.objects.create_user(	1✔
115	username="existing@example.com", password="Testpassword123"
116	)
117	form_data = {	1✔
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)	1✔
126	self.assertFalse(form.is_valid())	1✔
127	self.assertIn("email", form.errors)	1✔
128
129
130	class StudentFormTestCase(TestCase):	2✔
131	def test_student_form_valid_data(self):	2✔
132	form = StudentForm(	1✔
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())	1✔
145
146	def test_student_form_invalid_data(self):	2✔
147	form = StudentForm(data={})	1✔
148	self.assertFalse(form.is_valid())	1✔
149	self.assertEqual(len(form.errors), 8) # Assuming all fields are required	1✔
150
151	def test_student_form_gender_choices(self):	2✔
152	form = StudentForm()	1✔
153	self.assertEqual(	1✔
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()	1✔
164	self.assertEqual(	1✔
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()	1✔
187	self.assertEqual(	1✔
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(	1✔
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())	1✔
210	self.assertEqual(len(form.errors), 8)	1✔

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

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