gcivil-nyu-org / fall24-monday-team3 / 271

Committed 13 Dec 2024 12:03AM UTC coverage: 74.578% (-0.3%) from 74.837%

Build # 271

Build Type

push

travis-pro

Committed by

ivarfan

Commit Message

Deleted unused imported packages

Run Details

1370 of 1837 relevant lines covered (74.58%)

0.75 hits per line

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

98.57

/users/tests.py

from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth import get_user_model
from .models import EmailVerificationToken, PendingEmailChange
from django.core import mail
import uuid
import json


class UserSignUpTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.signup_url = reverse("signup")
        self.User = get_user_model()

    def test_signup_page_loads(self):
        response = self.client.get(self.signup_url)
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/signup.html")

    def test_successful_signup(self):
        data = {
            "username": "testuser",
            "email": "test@example.com",
            "password1": "testpass123!",
            "password2": "testpass123!",
            "first_name": "Test",
            "last_name": "User",
            "bio": "Test bio",
        }
        response = self.client.post(self.signup_url, data)
        self.assertEqual(response.status_code, 200)

        # Check user was created but not active
        user = self.User.objects.get(username="testuser")
        self.assertFalse(user.is_active)

        # Check verification email was sent
        self.assertEqual(len(mail.outbox), 1)
        self.assertIn("Verify your RentSense account", mail.outbox[0].subject)

    def test_invalid_signup_missing_fields(self):
        data = {
            "username": "testuser",
            "email": "test@example.com",
            # Missing required fields
        }
        response = self.client.post(self.signup_url, data)
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.User.objects.filter(username="testuser").exists())

    def test_invalid_signup_password_mismatch(self):
        data = {
            "username": "testuser",
            "email": "test@example.com",
            "password1": "testpass123!",
            "password2": "differentpass123!",
            "first_name": "Test",
            "last_name": "User",
        }
        response = self.client.post(self.signup_url, data)
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.User.objects.filter(username="testuser").exists())

    def test_duplicate_email_signup(self):
        # Create a user first
        self.User.objects.create_user(
            username="existing", email="test@example.com", password="testpass123!"
        )

        # Try to create another user with same email
        data = {
            "username": "testuser",
            "email": "test@example.com",
            "password1": "testpass123!",
            "password2": "testpass123!",
            "first_name": "Test",
            "last_name": "User",
        }
        response = self.client.post(self.signup_url, data)
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.User.objects.filter(username="testuser").exists())


class UserLoginTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser", email="test@example.com", password="testpass123!"
        )
        self.login_url = reverse("login")

    def test_login_page_loads(self):
        response = self.client.get(self.login_url)
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/login.html")

    def test_successful_login(self):
        response = self.client.post(
            self.login_url, {"username": "testuser", "password": "testpass123!"}
        )
        self.assertRedirects(response, reverse("home"))

    def test_invalid_login(self):
        response = self.client.post(
            self.login_url, {"username": "testuser", "password": "wrongpass"}
        )
        self.assertEqual(response.status_code, 200)
        # Check for the form's error messages
        form = response.context["form"]
        self.assertTrue(form.errors)  # Verify there are errors
        self.assertIn(
            "Please enter a correct username and password",
            form.errors.get("__all__")[0],
        )


class ProfileTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpass123!",
            first_name="Test",
            last_name="User",
        )
        self.client.login(username="testuser", password="testpass123!")

    def test_profile_page_loads(self):
        response = self.client.get(reverse("profile"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/profile.html")

    def test_edit_profile_without_email_change(self):
        data = {
            "first_name": "Updated",
            "last_name": "Name",
            "email": "test@example.com",
            "bio": "Updated bio",
        }
        response = self.client.post(
            reverse("edit_profile"), data=data, content_type="application/json"
        )
        self.assertEqual(response.status_code, 200)
        self.user.refresh_from_db()
        self.assertEqual(self.user.first_name, "Updated")

    def test_edit_profile_with_email_change(self):
        data = {
            "first_name": "Test",
            "last_name": "User",
            "email": "newemail@example.com",
            "bio": "Test bio",
            "email_changed": True,
        }
        response = self.client.post(
            reverse("edit_profile"), data=data, content_type="application/json"
        )
        self.assertEqual(response.status_code, 200)

        # Check that old email is still active
        self.user.refresh_from_db()
        self.assertEqual(self.user.email, "test@example.com")

        # Check that pending email change was created
        pending_change = PendingEmailChange.objects.get(user=self.user)
        self.assertEqual(pending_change.new_email, "newemail@example.com")

    def test_edit_profile_duplicate_email(self):

        data = {
            "first_name": "Test",
            "last_name": "User",
            "email": "other@example.com",  # Try to use other user's email
            "bio": "Test bio",
            "email_changed": True,
        }
        response = self.client.post(
            reverse("edit_profile"),
            data=json.dumps(data),
            content_type="application/json",
        )
        self.assertEqual(response.status_code, 200)
        response_data = response.json()
        self.assertFalse(response_data["success"])
        self.assertEqual(response_data["error"], "This email is already in use.")

        # Verify the user's email hasn't changed
        self.user.refresh_from_db()
        self.assertEqual(self.user.email, "test@example.com")

    def test_edit_profile_invalid_json(self):
        response = self.client.post(
            reverse("edit_profile"),
            data="invalid json",
            content_type="application/json",
        )
        self.assertEqual(response.status_code, 200)
        response_data = response.json()
        self.assertFalse(response_data["success"])


class EmailVerificationTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpass123!",
            is_active=False,
        )
        self.verification_token = EmailVerificationToken.objects.create(user=self.user)

    def test_email_verification(self):
        response = self.client.get(
            reverse("verify_email", kwargs={"token": self.verification_token.token})
        )
        self.assertRedirects(response, reverse("login"))

        # Check user is now active
        self.user.refresh_from_db()
        self.assertTrue(self.user.is_active)

        # Check verification token is marked as verified
        self.verification_token.refresh_from_db()
        self.assertTrue(self.verification_token.is_verified)

    def test_invalid_verification_token(self):
        response = self.client.get(
            reverse("verify_email", kwargs={"token": uuid.uuid4()})
        )
        self.assertEqual(response.status_code, 404)

    def test_verify_already_verified_token(self):
        # First verification
        self.client.get(
            reverse("verify_email", kwargs={"token": self.verification_token.token})
        )

        # Try to verify again
        response = self.client.get(
            reverse("verify_email", kwargs={"token": self.verification_token.token})
        )
        self.assertEqual(response.status_code, 404)

    def test_verify_email_change(self):
        # Create a user and pending email change
        user = self.User.objects.create_user(
            username="testuser2", email="old@example.com", password="testpass123!"
        )
        pending_change = PendingEmailChange.objects.create(
            user=user, new_email="new@example.com"
        )

        # Login the user first
        self.client.login(username="testuser2", password="testpass123!")

        # Verify the email change
        response = self.client.get(
            reverse("verify_email_change", kwargs={"token": pending_change.token})
        )
        self.assertRedirects(response, reverse("profile"))

        # Check that email was updated
        user.refresh_from_db()
        self.assertEqual(user.email, "new@example.com")

        # Check that pending change was deleted
        self.assertFalse(
            PendingEmailChange.objects.filter(token=pending_change.token).exists()
        )


class PublicProfileTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpass123!",
            first_name="Test",
            last_name="User",
            bio="Test bio",
        )

    def test_public_profile_view(self):
        self.client.login(username="testuser", password="testpass123!")
        response = self.client.get(
            reverse("public_profile", kwargs={"username": "testuser"})
        )
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/public_profile.html")
        self.assertEqual(response.context["profile_user"], self.user)

    def test_nonexistent_profile_view(self):
        self.client.login(username="testuser", password="testpass123!")
        response = self.client.get(
            reverse("public_profile", kwargs={"username": "nonexistent"})
        )
        self.assertEqual(response.status_code, 404)

    def test_unauthenticated_profile_access(self):
        response = self.client.get(
            reverse("public_profile", kwargs={"username": "testuser"})
        )
        self.assertRedirects(
            response,
            f"{reverse('login')}?next={reverse('public_profile', kwargs={'username': 'testuser'})}",
        )


class UserModelTest(TestCase):
    def setUp(self):
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpass123!",
            first_name="Test",
            last_name="User",
            bio="Test bio",
        )

    def test_user_str_method(self):
        self.assertEqual(str(self.user), "testuser")

    def test_user_full_name(self):
        self.assertEqual(self.user.get_full_name(), "Test User")

    def test_user_short_name(self):
        self.assertEqual(self.user.get_short_name(), "Test")


class EmailVerificationTokenTest(TestCase):
    def setUp(self):
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser", email="test@example.com", password="testpass123!"
        )
        self.token = EmailVerificationToken.objects.create(user=self.user)

    def test_token_str_method(self):
        self.assertEqual(str(self.token), f"Token for {self.user.email}")

    def test_token_creation(self):
        self.assertIsNotNone(self.token.token)
        self.assertFalse(self.token.is_verified)
        self.assertIsNotNone(self.token.created_at)


class PendingEmailChangeTest(TestCase):
    def setUp(self):
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser", email="test@example.com", password="testpass123!"
        )
        self.pending_change = PendingEmailChange.objects.create(
            user=self.user, new_email="new@example.com"
        )

    def test_pending_change_str_method(self):
        expected = (
            f"Email change for {self.user.username} to {self.pending_change.new_email}"
        )
        self.assertEqual(str(self.pending_change), expected)

    def test_token_generation(self):
        self.assertIsNotNone(self.pending_change.token)
        self.assertIsInstance(self.pending_change.token, uuid.UUID)


class UserViewsTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.User = get_user_model()
        self.user = self.User.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpass123!",
            is_active=True,
        )
        self.client.login(username="testuser", password="testpass123!")

    def test_home_view_authenticated(self):
        self.client.login(username="testuser", password="testpass123!")
        response = self.client.get(reverse("home"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/home.html")

    def test_home_view_unauthenticated(self):
        response = self.client.get(reverse("home"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/home.html")

    def test_send_user_email(self):
        data = {"subject": "Test Subject", "message": "Test Message"}
        response = self.client.post(
            reverse("send_user_email", kwargs={"username": "testuser"}),
            data=json.dumps(data),
            content_type="application/json",
        )
        self.assertEqual(response.status_code, 200)
        response_data = response.json()
        self.assertTrue(response_data["success"])
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].subject, "Test Subject")

    def test_send_user_email_invalid_user(self):
        data = {"subject": "Test Subject", "message": "Test Message"}
        response = self.client.post(
            reverse("send_user_email", kwargs={"username": "nonexistent"}),
            data=json.dumps(data),
            content_type="application/json",
        )
        self.assertEqual(response.status_code, 404)
        response_data = response.json()
        self.assertFalse(response_data["success"])

    def test_send_user_email_invalid_json(self):
        response = self.client.post(
            reverse("send_user_email", kwargs={"username": "testuser"}),
            data="invalid json",
            content_type="application/json",
        )
        self.assertEqual(response.status_code, 400)
        response_data = response.json()
        self.assertFalse(response_data["success"])

1	from django.test import TestCase, Client	1✔
2	from django.urls import reverse	1✔
3	from django.contrib.auth import get_user_model	1✔
4	from .models import EmailVerificationToken, PendingEmailChange	1✔
5	from django.core import mail	1✔
6	import uuid	1✔
7	import json	1✔
8
9
10	class UserSignUpTest(TestCase):	1✔
11	def setUp(self):	1✔
12	self.client = Client()	1✔
13	self.signup_url = reverse("signup")	1✔
14	self.User = get_user_model()	1✔
15
16	def test_signup_page_loads(self):	1✔
17	response = self.client.get(self.signup_url)	1✔
18	self.assertEqual(response.status_code, 200)	1✔
19	self.assertTemplateUsed(response, "users/signup.html")	1✔
20
21	def test_successful_signup(self):	1✔
22	data = {	1✔
23	"username": "testuser",
24	"email": "test@example.com",
25	"password1": "testpass123!",
26	"password2": "testpass123!",
27	"first_name": "Test",
28	"last_name": "User",
29	"bio": "Test bio",
30	}
31	response = self.client.post(self.signup_url, data)	1✔
32	self.assertEqual(response.status_code, 200)	1✔
33
34	# Check user was created but not active
35	user = self.User.objects.get(username="testuser")	1✔
36	self.assertFalse(user.is_active)	1✔
37
38	# Check verification email was sent
39	self.assertEqual(len(mail.outbox), 1)	1✔
40	self.assertIn("Verify your RentSense account", mail.outbox[0].subject)	1✔
41
42	def test_invalid_signup_missing_fields(self):	1✔
43	data = {	1✔
44	"username": "testuser",
45	"email": "test@example.com",
46	# Missing required fields
47	}
48	response = self.client.post(self.signup_url, data)	1✔
49	self.assertEqual(response.status_code, 200)	1✔
50	self.assertFalse(self.User.objects.filter(username="testuser").exists())	1✔
51
52	def test_invalid_signup_password_mismatch(self):	1✔
53	data = {	1✔
54	"username": "testuser",
55	"email": "test@example.com",
56	"password1": "testpass123!",
57	"password2": "differentpass123!",
58	"first_name": "Test",
59	"last_name": "User",
60	}
61	response = self.client.post(self.signup_url, data)	1✔
62	self.assertEqual(response.status_code, 200)	1✔
63	self.assertFalse(self.User.objects.filter(username="testuser").exists())	1✔
64
65	def test_duplicate_email_signup(self):	1✔
66	# Create a user first
67	self.User.objects.create_user(	1✔
68	username="existing", email="test@example.com", password="testpass123!"
69	)
70
71	# Try to create another user with same email
72	data = {	1✔
73	"username": "testuser",
74	"email": "test@example.com",
75	"password1": "testpass123!",
76	"password2": "testpass123!",
77	"first_name": "Test",
78	"last_name": "User",
79	}
80	response = self.client.post(self.signup_url, data)	1✔
81	self.assertEqual(response.status_code, 200)	1✔
82	self.assertFalse(self.User.objects.filter(username="testuser").exists())	1✔
83
84
85	class UserLoginTest(TestCase):	1✔
86	def setUp(self):	1✔
87	self.client = Client()	1✔
88	self.User = get_user_model()	1✔
89	self.user = self.User.objects.create_user(	1✔
90	username="testuser", email="test@example.com", password="testpass123!"
91	)
92	self.login_url = reverse("login")	1✔
93
94	def test_login_page_loads(self):	1✔
95	response = self.client.get(self.login_url)	1✔
96	self.assertEqual(response.status_code, 200)	1✔
97	self.assertTemplateUsed(response, "users/login.html")	1✔
98
99	def test_successful_login(self):	1✔
100	response = self.client.post(	1✔
101	self.login_url, {"username": "testuser", "password": "testpass123!"}
102	)
103	self.assertRedirects(response, reverse("home"))	1✔
104
105	def test_invalid_login(self):	1✔
106	response = self.client.post(	1✔
107	self.login_url, {"username": "testuser", "password": "wrongpass"}
108	)
109	self.assertEqual(response.status_code, 200)	1✔
110	# Check for the form's error messages
111	form = response.context["form"]	1✔
112	self.assertTrue(form.errors) # Verify there are errors	1✔
113	self.assertIn(	1✔
114	"Please enter a correct username and password",
115	form.errors.get("__all__")[0],
116	)
117
118
119	class ProfileTest(TestCase):	1✔
120	def setUp(self):	1✔
121	self.client = Client()	1✔
122	self.User = get_user_model()	1✔
123	self.user = self.User.objects.create_user(	1✔
124	username="testuser",
125	email="test@example.com",
126	password="testpass123!",
127	first_name="Test",
128	last_name="User",
129	)
130	self.client.login(username="testuser", password="testpass123!")	1✔
131
132	def test_profile_page_loads(self):	1✔
133	response = self.client.get(reverse("profile"))	1✔
134	self.assertEqual(response.status_code, 200)	1✔
135	self.assertTemplateUsed(response, "users/profile.html")	1✔
136
137	def test_edit_profile_without_email_change(self):	1✔
138	data = {	1✔
139	"first_name": "Updated",
140	"last_name": "Name",
141	"email": "test@example.com",
142	"bio": "Updated bio",
143	}
144	response = self.client.post(	1✔
145	reverse("edit_profile"), data=data, content_type="application/json"
146	)
147	self.assertEqual(response.status_code, 200)	1✔
148	self.user.refresh_from_db()	1✔
149	self.assertEqual(self.user.first_name, "Updated")	1✔
150
151	def test_edit_profile_with_email_change(self):	1✔
152	data = {	1✔
153	"first_name": "Test",
154	"last_name": "User",
155	"email": "newemail@example.com",
156	"bio": "Test bio",
157	"email_changed": True,
158	}
159	response = self.client.post(	1✔
160	reverse("edit_profile"), data=data, content_type="application/json"
161	)
162	self.assertEqual(response.status_code, 200)	1✔
163
164	# Check that old email is still active
165	self.user.refresh_from_db()	1✔
166	self.assertEqual(self.user.email, "test@example.com")	1✔
167
168	# Check that pending email change was created
169	pending_change = PendingEmailChange.objects.get(user=self.user)	1✔
170	self.assertEqual(pending_change.new_email, "newemail@example.com")	1✔
171
172	def test_edit_profile_duplicate_email(self):	1✔
173
174	data = {	1✔
175	"first_name": "Test",
176	"last_name": "User",
177	"email": "other@example.com", # Try to use other user's email
178	"bio": "Test bio",
179	"email_changed": True,
180	}
181	response = self.client.post(	1✔
182	reverse("edit_profile"),
183	data=json.dumps(data),
184	content_type="application/json",
185	)
186	self.assertEqual(response.status_code, 200)	1✔
187	response_data = response.json()	1✔
188	self.assertFalse(response_data["success"])	1✔
189	self.assertEqual(response_data["error"], "This email is already in use.")	×
190
191	# Verify the user's email hasn't changed
192	self.user.refresh_from_db()	×
193	self.assertEqual(self.user.email, "test@example.com")	×
194
195	def test_edit_profile_invalid_json(self):	1✔
196	response = self.client.post(	1✔
197	reverse("edit_profile"),
198	data="invalid json",
199	content_type="application/json",
200	)
201	self.assertEqual(response.status_code, 200)	1✔
202	response_data = response.json()	1✔
203	self.assertFalse(response_data["success"])	1✔
204
205
206	class EmailVerificationTest(TestCase):	1✔
207	def setUp(self):	1✔
208	self.client = Client()	1✔
209	self.User = get_user_model()	1✔
210	self.user = self.User.objects.create_user(	1✔
211	username="testuser",
212	email="test@example.com",
213	password="testpass123!",
214	is_active=False,
215	)
216	self.verification_token = EmailVerificationToken.objects.create(user=self.user)	1✔
217
218	def test_email_verification(self):	1✔
219	response = self.client.get(	1✔
220	reverse("verify_email", kwargs={"token": self.verification_token.token})
221	)
222	self.assertRedirects(response, reverse("login"))	1✔
223
224	# Check user is now active
225	self.user.refresh_from_db()	1✔
226	self.assertTrue(self.user.is_active)	1✔
227
228	# Check verification token is marked as verified
229	self.verification_token.refresh_from_db()	1✔
230	self.assertTrue(self.verification_token.is_verified)	1✔
231
232	def test_invalid_verification_token(self):	1✔
233	response = self.client.get(	1✔
234	reverse("verify_email", kwargs={"token": uuid.uuid4()})
235	)
236	self.assertEqual(response.status_code, 404)	1✔
237
238	def test_verify_already_verified_token(self):	1✔
239	# First verification
240	self.client.get(	1✔
241	reverse("verify_email", kwargs={"token": self.verification_token.token})
242	)
243
244	# Try to verify again
245	response = self.client.get(	1✔
246	reverse("verify_email", kwargs={"token": self.verification_token.token})
247	)
248	self.assertEqual(response.status_code, 404)	1✔
249
250	def test_verify_email_change(self):	1✔
251	# Create a user and pending email change
252	user = self.User.objects.create_user(	1✔
253	username="testuser2", email="old@example.com", password="testpass123!"
254	)
255	pending_change = PendingEmailChange.objects.create(	1✔
256	user=user, new_email="new@example.com"
257	)
258
259	# Login the user first
260	self.client.login(username="testuser2", password="testpass123!")	1✔
261
262	# Verify the email change
263	response = self.client.get(	1✔
264	reverse("verify_email_change", kwargs={"token": pending_change.token})
265	)
266	self.assertRedirects(response, reverse("profile"))	1✔
267
268	# Check that email was updated
269	user.refresh_from_db()	1✔
270	self.assertEqual(user.email, "new@example.com")	1✔
271
272	# Check that pending change was deleted
273	self.assertFalse(	1✔
274	PendingEmailChange.objects.filter(token=pending_change.token).exists()
275	)
276
277
278	class PublicProfileTest(TestCase):	1✔
279	def setUp(self):	1✔
280	self.client = Client()	1✔
281	self.User = get_user_model()	1✔
282	self.user = self.User.objects.create_user(	1✔
283	username="testuser",
284	email="test@example.com",
285	password="testpass123!",
286	first_name="Test",
287	last_name="User",
288	bio="Test bio",
289	)
290
291	def test_public_profile_view(self):	1✔
292	self.client.login(username="testuser", password="testpass123!")	1✔
293	response = self.client.get(	1✔
294	reverse("public_profile", kwargs={"username": "testuser"})
295	)
296	self.assertEqual(response.status_code, 200)	1✔
297	self.assertTemplateUsed(response, "users/public_profile.html")	1✔
298	self.assertEqual(response.context["profile_user"], self.user)	1✔
299
300	def test_nonexistent_profile_view(self):	1✔
301	self.client.login(username="testuser", password="testpass123!")	1✔
302	response = self.client.get(	1✔
303	reverse("public_profile", kwargs={"username": "nonexistent"})
304	)
305	self.assertEqual(response.status_code, 404)	1✔
306
307	def test_unauthenticated_profile_access(self):	1✔
308	response = self.client.get(	1✔
309	reverse("public_profile", kwargs={"username": "testuser"})
310	)
311	self.assertRedirects(	1✔
312	response,
313	f"{reverse('login')}?next={reverse('public_profile', kwargs={'username': 'testuser'})}",
314	)
315
316
317	class UserModelTest(TestCase):	1✔
318	def setUp(self):	1✔
319	self.User = get_user_model()	1✔
320	self.user = self.User.objects.create_user(	1✔
321	username="testuser",
322	email="test@example.com",
323	password="testpass123!",
324	first_name="Test",
325	last_name="User",
326	bio="Test bio",
327	)
328
329	def test_user_str_method(self):	1✔
330	self.assertEqual(str(self.user), "testuser")	1✔
331
332	def test_user_full_name(self):	1✔
333	self.assertEqual(self.user.get_full_name(), "Test User")	1✔
334
335	def test_user_short_name(self):	1✔
336	self.assertEqual(self.user.get_short_name(), "Test")	1✔
337
338
339	class EmailVerificationTokenTest(TestCase):	1✔
340	def setUp(self):	1✔
341	self.User = get_user_model()	1✔
342	self.user = self.User.objects.create_user(	1✔
343	username="testuser", email="test@example.com", password="testpass123!"
344	)
345	self.token = EmailVerificationToken.objects.create(user=self.user)	1✔
346
347	def test_token_str_method(self):	1✔
348	self.assertEqual(str(self.token), f"Token for {self.user.email}")	1✔
349
350	def test_token_creation(self):	1✔
351	self.assertIsNotNone(self.token.token)	1✔
352	self.assertFalse(self.token.is_verified)	1✔
353	self.assertIsNotNone(self.token.created_at)	1✔
354
355
356	class PendingEmailChangeTest(TestCase):	1✔
357	def setUp(self):	1✔
358	self.User = get_user_model()	1✔
359	self.user = self.User.objects.create_user(	1✔
360	username="testuser", email="test@example.com", password="testpass123!"
361	)
362	self.pending_change = PendingEmailChange.objects.create(	1✔
363	user=self.user, new_email="new@example.com"
364	)
365
366	def test_pending_change_str_method(self):	1✔
367	expected = (	1✔
368	f"Email change for {self.user.username} to {self.pending_change.new_email}"
369	)
370	self.assertEqual(str(self.pending_change), expected)	1✔
371
372	def test_token_generation(self):	1✔
373	self.assertIsNotNone(self.pending_change.token)	1✔
374	self.assertIsInstance(self.pending_change.token, uuid.UUID)	1✔
375
376
377	class UserViewsTest(TestCase):	1✔
378	def setUp(self):	1✔
379	self.client = Client()	1✔
380	self.User = get_user_model()	1✔
381	self.user = self.User.objects.create_user(	1✔
382	username="testuser",
383	email="test@example.com",
384	password="testpass123!",
385	is_active=True,
386	)
387	self.client.login(username="testuser", password="testpass123!")	1✔
388
389	def test_home_view_authenticated(self):	1✔
390	self.client.login(username="testuser", password="testpass123!")	1✔
391	response = self.client.get(reverse("home"))	1✔
392	self.assertEqual(response.status_code, 200)	1✔
393	self.assertTemplateUsed(response, "users/home.html")	1✔
394
395	def test_home_view_unauthenticated(self):	1✔
396	response = self.client.get(reverse("home"))	1✔
397	self.assertEqual(response.status_code, 200)	1✔
398	self.assertTemplateUsed(response, "users/home.html")	1✔
399
400	def test_send_user_email(self):	1✔
401	data = {"subject": "Test Subject", "message": "Test Message"}	1✔
402	response = self.client.post(	1✔
403	reverse("send_user_email", kwargs={"username": "testuser"}),
404	data=json.dumps(data),
405	content_type="application/json",
406	)
407	self.assertEqual(response.status_code, 200)	1✔
408	response_data = response.json()	1✔
409	self.assertTrue(response_data["success"])	1✔
410	self.assertEqual(len(mail.outbox), 1)	1✔
411	self.assertEqual(mail.outbox[0].subject, "Test Subject")	1✔
412
413	def test_send_user_email_invalid_user(self):	1✔
414	data = {"subject": "Test Subject", "message": "Test Message"}	1✔
415	response = self.client.post(	1✔
416	reverse("send_user_email", kwargs={"username": "nonexistent"}),
417	data=json.dumps(data),
418	content_type="application/json",
419	)
420	self.assertEqual(response.status_code, 404)	1✔
421	response_data = response.json()	1✔
422	self.assertFalse(response_data["success"])	1✔
423
424	def test_send_user_email_invalid_json(self):	1✔
425	response = self.client.post(	1✔
426	reverse("send_user_email", kwargs={"username": "testuser"}),
427	data="invalid json",
428	content_type="application/json",
429	)
430	self.assertEqual(response.status_code, 400)	1✔
431	response_data = response.json()	1✔
432	self.assertFalse(response_data["success"])	1✔

gcivil-nyu-org / fall24-monday-team3 / 271

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