gcivil-nyu-org / INET-Wednesday-Spring2024-Team-1 / 342

Committed 30 Apr 2024 07:50PM UTC coverage: 83.513%. Remained the same

Build # 342

Build Type

Pull #122

travis-pro

Committed by

web-flow

Commit Message

Merge 56f0cabc5 into 12481fa66

Pull Request Pull Request #122: refactored grocery store functions

Run Details

466 of 558 relevant lines covered (83.51%)

1.19 hits per line

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

95.45

/users/tests.py

import datetime
from django.test import TestCase, Client, RequestFactory
from django.urls import reverse
from django.contrib.auth.models import User
from django.http import HttpResponseRedirect
from django.contrib.auth.models import AnonymousUser
from django.contrib.sessions.middleware import SessionMiddleware
from django.db import models
from .models import CustomUser, UserPreferences, Cuisine, Allergy
from django.utils import timezone
from .views import preferences, login_redirect, set_preferences, skip_preferences
from django.dispatch import Signal
from .signals import update_custom_user, user_logged_in, user_signed_up
from .forms import UserSignUpForm
from unittest.mock import patch
from django.utils import timezone
from freezegun import freeze_time
from unittest.mock import MagicMock
from rest_framework.test import force_authenticate


class UserPreferencesTestCase(TestCase):
    def setUp(self):
        # Create a test user
        self.factory = RequestFactory()
        User.objects.create_user(
            username="testuser", email="test@example.com", last_login=timezone.now()
        )
        self.customUser = CustomUser.objects.create(
            username="testuser",
            email="test@example.com",
            preferences="True",
            last_login=timezone.now(),
        )
        self.client = Client()

    def test_authenticated_user_redirect_to_homepage(self):
        request = self.factory.get(reverse("login"))
        request.user = self.customUser
        request.user.is_authenticated = lambda: True
        response = login_redirect(request)
        self.assertIsInstance(response, HttpResponseRedirect)
        self.assertEqual(response.url, reverse("homepage"))

    def test_unauthenticated_user_render_login_page(self):
        request = self.factory.get(reverse("login"))
        request.user = AnonymousUser()
        response = login_redirect(request)
        self.assertEqual(response.status_code, 200)
        self.assertIn("Continue with Google", response.content.decode())

    def test_create_custom_user(self):
        # Create a CustomUser object
        CustomUser.objects.create(
            username="test",
            email="test@test.com",
            preferences=True,  # Set preferences to True for demonstration
            last_login=timezone.make_aware(
                timezone.datetime(2022, 1, 1)
            ),  # Set last_login to a specific datetime for demonstration
        )

        # Retrieve the created CustomUser object from the database
        retrieved_custom_user = CustomUser.objects.get(email="test@test.com")

        # Verify that the retrieved CustomUser object matches the expected values
        self.assertEqual(retrieved_custom_user.username, "test")
        self.assertEqual(retrieved_custom_user.email, "test@test.com")
        self.assertEqual(retrieved_custom_user.preferences, True)
        self.assertEqual(
            retrieved_custom_user.last_login,
            timezone.make_aware(timezone.datetime(2022, 1, 1)),
        )

    def test_create_user_preferences(self):
        # Create user preferences
        UserPreferences.objects.create(
            user=self.customUser,
            phone_number="1234567890",
            address="Test Address",
            diet="vegetarian",
            height=170,
            weight=150,
            target_weight=140,
        )

        self.cuisine1 = Cuisine.objects.create(name="Chinese")
        self.cuisine2 = Cuisine.objects.create(name="Indian")
        self.allergy1 = Allergy.objects.create(name="Dairy")
        self.allergy2 = Allergy.objects.create(name="Nuts")

        # Retrieve the created user preferences
        user_preferences = UserPreferences.objects.get(user=self.customUser)
        user_preferences.cuisines.add(self.cuisine1)
        user_preferences.allergies.add(self.allergy1)

        # Check if the created user preferences match the provided data
        self.assertEqual(user_preferences.phone_number, "1234567890")
        self.assertEqual(user_preferences.address, "Test Address")
        self.assertEqual(user_preferences.diet, "vegetarian")
        self.assertEqual(user_preferences.height, 170)
        self.assertEqual(user_preferences.weight, 150)
        self.assertEqual(user_preferences.target_weight, 140)

        # Check if cuisines and allergies are properly associated
        self.assertIn(self.cuisine1, user_preferences.cuisines.all())
        self.assertNotIn(self.cuisine2, user_preferences.cuisines.all())
        self.assertIn(self.allergy1, user_preferences.allergies.all())
        self.assertNotIn(self.allergy2, user_preferences.allergies.all())

    def test_update_user_preferences(self):
        # Create user preferences
        user_preferences = UserPreferences.objects.create(
            user=self.customUser,
            phone_number="1234567890",
            address="Test Address",
            diet="vegetarian",
            height=170,
            weight=150,
            target_weight=140,
        )

        # Update user preferences
        user_preferences.diet = "vegan"
        user_preferences.save()

        # Retrieve the updated user preferences
        updated_preferences = UserPreferences.objects.get(user=self.customUser)

        # Check if the diet field is updated
        self.assertEqual(updated_preferences.diet, "vegan")

    def test_delete_user_preferences(self):
        user_preferences = UserPreferences.objects.create(
            user=self.customUser,
            phone_number="1234567890",
            address="Test Address",
            diet="vegetarian",
            height=170,
            weight=150,
            target_weight=140,
        )

        # Delete user preferences
        user_preferences.delete()

        # Ensure the preferences are deleted
        with self.assertRaises(UserPreferences.DoesNotExist):
            UserPreferences.objects.get(user=self.customUser)

    def test_set_preferences_valid_data_anonymous(self):
        data = {
            "phone": "1234567890",
            "address": "Test Address",
            "diet": "vegetarian",
            "cuisine": ["Indian", "Italian"],
            "allergies": ["Dairy", "Nuts"],
            "height": "170",
            "weight": "150",
            "targetWeight": "140",
        }
        request = self.factory.get(reverse("setPreferences"))
        request.user = AnonymousUser()
        request.data = data
        response = set_preferences(request)
        self.assertEqual(
            response.status_code, 302
        )  # Redirects to login page for anonymous users

    def test_set_preferences_anonymous(self):
        request = self.factory.get(reverse("setPreferences"))
        request.user = AnonymousUser()
        response = set_preferences(request)
        self.assertEqual(response.status_code, 302)

    def test_set_preferences_valid_data_authenticated_set(self):
        data = {
            "phone": "1234567890",
            "address": "Test Address",
            "diet": "vegetarian",
            "cuisine": ["Indian", "Italian"],
            "allergies": ["Dairy", "Nuts"],
            "height": "170",
            "weight": "150",
            "targetWeight": "140",
        }

        fq = RequestFactory()
        custom_user = CustomUser.objects.create(
            username="test", email="test@test.com", preferences="False"
        )
        request = fq.post(reverse("setPreferences"), data=data)

        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        request.user = custom_user
        force_authenticate(request, user=custom_user)

        request.user.is_authenticated = lambda: True
        response = set_preferences(request)
        self.assertTrue(request.session["preferences_updated"])
        self.assertTrue(request.session["preferences_set"])
        self.assertTrue(request.session["check_user_preferences"])
        # Check if the response status code is 302
        self.assertEqual(response.status_code, 302)

    # def test_set_preferences_valid_data_authenticated_update(self):
    #     data = {
    #         'cuisine': ['Indian'],
    #         'allergies': ['Dairy']
    #     }
    #     fq = RequestFactory()
    #     custom_user = CustomUser.objects.create(
    #         username="test", email="test@test.com", preferences="True"
    #     )
    #     request = fq.post(reverse("setPreferences"), data=data)

    #     middleware = SessionMiddleware(lambda req: None)
    #     middleware.process_request(request)
    #     request.session.save()

    #     request.user = custom_user
    #     force_authenticate(request, user=custom_user)

    #     request.user.is_authenticated = lambda: True

    #     response = set_preferences(request)
    #     self.assertTrue(request.session['preferences_updated'])
    #     self.assertEqual(response.status_code, 302)

    def test_set_preferences_invalid_data_authenticated_set(self):
        data = {
            "address": "Test Address",
            "diet": "vegetarian",
            "cuisine": ["Indian", "Italian"],
            "allergies": ["Dairy", "Nuts"],
            "height": "170",
            "weight": "150",
            "targetWeight": "140",
        }
        custom_user = CustomUser.objects.create(
            username="test", email="test@test.com", preferences="False"
        )
        custom_user_instance = CustomUser.objects.get(email=custom_user.email)
        request = self.factory.post(reverse("setPreferences"))
        request.user = custom_user_instance
        request.user.is_authenticated = lambda: True
        request.data = data
        response = set_preferences(request)
        self.assertEqual(response.status_code, 400)

    def test_skip_preferences_ajax_anonymous(self):
        request = self.factory.get(reverse("skipPreferences"))
        request.user = AnonymousUser()
        response = skip_preferences(request)
        self.assertEqual(response.status_code, 302)

    def test_skip_preferences_ajax_authenticated(self):
        request = self.factory.get(reverse("skipPreferences"))
        request.user = self.customUser
        request.user.is_authenticated = lambda: True
        response = skip_preferences(request)
        self.assertEqual(response.status_code, 302)

    def test_preferences_unauthenticated(self):
        # Make a GET request to the preferences view without logging in
        request = self.factory.get(reverse("preferences"))
        request.user = AnonymousUser()
        response = preferences(request)
        self.assertEqual(response.status_code, 302)

    def test_preferences_authenticated_no_preferences(self):
        # Make a GET request to the preferences view after logging in
        custom_user = CustomUser.objects.create(username="test", email="test@test.com")
        request = self.factory.get(reverse("preferences"))
        request.user = custom_user
        request.user.is_authenticated = lambda: True
        response = preferences(request)
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.template_name, "users/preferences.html")
        self.assertEqual(response.context_data["preferences"], None)

    def test_preferences_authenticated_with_preferences(self):
        UserPreferences.objects.create(
            user=self.customUser,
            phone_number="1234567890",
            address="Test Address",
            diet="Vegetarian",
            height=170,
            weight=60,
            target_weight=55,
        )
        cuisine1 = Cuisine.objects.create(name="Chinese")
        cuisine2 = Cuisine.objects.create(name="Italian")
        allergy1 = Allergy.objects.create(name="Dairy")

        # Retrieve the created user preferences
        user_preferences = UserPreferences.objects.get(user=self.customUser)
        user_preferences.cuisines.add(cuisine1)
        user_preferences.cuisines.add(cuisine2)
        user_preferences.allergies.add(allergy1)

        request = self.factory.get(reverse("preferences"))
        request.user = self.customUser
        request.user.is_authenticated = lambda: True
        response = preferences(request)

        # Assert that the preferences are rendered correctly
        self.assertEqual(response.template_name, "users/preferences.html")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            response.context_data["preferences"]["phone_number"], "1234567890"
        )
        self.assertEqual(
            response.context_data["preferences"]["address"], "Test Address"
        )
        self.assertEqual(response.context_data["preferences"]["diet"], "Vegetarian")
        # self.assertEqual(response.context_data['preferences']['cuisines'], ['Italian', 'Chinese'])
        self.assertEqual(response.context_data["preferences"]["allergies"], ["Dairy"])
        self.assertEqual(response.context_data["preferences"]["height"], 170)
        self.assertEqual(response.context_data["preferences"]["weight"], 60)
        self.assertEqual(response.context_data["preferences"]["target_weight"], 55)

    def test_update_custom_user_existing(self):
        # Simulate the user_logged_in event
        user_logged_in = Signal()
        user_logged_in.send(sender=self.customUser.__class__, user=self.customUser)

        # Retrieve the CustomUser object from the database
        custom_user = CustomUser.objects.get(email=self.customUser.email)

        # Verify that the CustomUser's last_login is updated
        self.assertTrue(
            custom_user.last_login > timezone.now() - timezone.timedelta(seconds=1)
        )

    def test_update_custom_user_new(self):
        customUser = CustomUser.objects.create(username="test", email="test@test.com")
        user_logged_in = Signal()
        # Simulate the user_logged_in event for a new user
        user_logged_in.send(sender=customUser.__class__, user=customUser)

        # Retrieve the CustomUser object from the database
        custom_user = CustomUser.objects.get(email=customUser.email)

        # Verify that a new CustomUser object is created with the correct data
        self.assertEqual(custom_user.email, customUser.email)
        self.assertEqual(custom_user.username, customUser.username)
        self.assertEqual(custom_user.preferences, False)

    def test_clean_email_unique(self):
        # Test that clean_email method raises ValidationError for existing email
        form_data = {
            "username": "test_user",
            "email": "test@example.com",
            "password": "testpassword",
        }
        form = UserSignUpForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)
        self.assertEqual(form.errors["email"], ["Email already exists."])

    def test_clean_username_unique(self):
        # Test that clean_username method raises ValidationError for existing username
        form_data = {
            "username": "testuser",
            "email": "testing@example.com",
            "password": "testpassword",
        }
        form = UserSignUpForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("username", form.errors)
        self.assertEqual(form.errors["username"], ["Username already exists."])

    def test_update_custom_user_existing(self):
        # CustomUser.objects.create(username=self.user.username, email=self.user.email)
        request = self.factory.get("/")
        request.user = self.customUser
        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        update_custom_user(CustomUser, self.customUser, request)
        custom_user = CustomUser.objects.get(username=self.customUser.username)

        self.assertEqual(custom_user.last_login.date(), timezone.now().date())
        self.assertEqual(
            request.session["check_user_preferences"], custom_user.preferences
        )
        self.assertEqual(request.session["username"], self.customUser.username)

    def test_update_custom_user_new(self):
        request = self.factory.get("/")
        request.user = self.customUser
        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        update_custom_user(User, self.customUser, request)
        custom_user = CustomUser.objects.get(username=self.customUser.username)

        self.assertEqual(custom_user.last_login.date(), timezone.now().date())
        self.assertEqual(request.session["username"], self.customUser.username)

    @patch("users.signals.CustomUser.objects.create")
    @freeze_time("2024-04-10 16:39:55")
    def test_user_signed_up(self, mock_create):
        data = {"username": "testuser", "email": "test@otherexample.com"}
        request = self.factory.get("/")
        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        user_signed_up(data, request)

        mock_create.assert_called_once_with(
            username=data["username"],
            email=data["email"],
            preferences=False,
            last_login=timezone.now(),
        )
        self.assertEqual(request.session["check_user_preferences"], "False")
        self.assertEqual(request.session["username"], data["username"])

    @freeze_time("2024-04-10 16:39:55")
    def test_update_custom_user_new_user(self):
        request = self.factory.get("/")
        User.objects.create_user(
            username="newuser", email="newuser@example.com", last_login=timezone.now()
        )
        request.user = User.objects.get(username="newuser")
        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        update_custom_user(User, request.user, request)
        custom_user = CustomUser.objects.get(username=request.user.username)

        self.assertEqual(custom_user.last_login.date(), timezone.now().date())
        self.assertEqual(request.session["username"], request.user.username)

    @freeze_time("2024-04-10 16:39:55")
    def test_user_signed_up_no_mock(self):
        data = {"username": "testotheruser", "email": "test@someotherexample.com"}
        request = self.factory.get("/")
        middleware = SessionMiddleware(lambda req: None)
        middleware.process_request(request)
        request.session.save()

        user_signed_up(data, request)

        custom_user = CustomUser.objects.get(username=data["username"])
        self.assertEqual(custom_user.last_login.date(), timezone.now().date())
        self.assertEqual(request.session["check_user_preferences"], "False")
        self.assertEqual(request.session["username"], data["username"])

1	import datetime	2✔
2	from django.test import TestCase, Client, RequestFactory	2✔
3	from django.urls import reverse	2✔
4	from django.contrib.auth.models import User	2✔
5	from django.http import HttpResponseRedirect	2✔
6	from django.contrib.auth.models import AnonymousUser	2✔
7	from django.contrib.sessions.middleware import SessionMiddleware	2✔
8	from django.db import models	2✔
9	from .models import CustomUser, UserPreferences, Cuisine, Allergy	2✔
10	from django.utils import timezone	2✔
11	from .views import preferences, login_redirect, set_preferences, skip_preferences	2✔
12	from django.dispatch import Signal	2✔
13	from .signals import update_custom_user, user_logged_in, user_signed_up	2✔
14	from .forms import UserSignUpForm	2✔
15	from unittest.mock import patch	2✔
16	from django.utils import timezone	2✔
17	from freezegun import freeze_time	2✔
18	from unittest.mock import MagicMock	2✔
19	from rest_framework.test import force_authenticate	2✔
20
21
22	class UserPreferencesTestCase(TestCase):	2✔
23	def setUp(self):	2✔
24	# Create a test user
25	self.factory = RequestFactory()	1✔
26	User.objects.create_user(	1✔
27	username="testuser", email="test@example.com", last_login=timezone.now()
28	)
29	self.customUser = CustomUser.objects.create(	1✔
30	username="testuser",
31	email="test@example.com",
32	preferences="True",
33	last_login=timezone.now(),
34	)
35	self.client = Client()	1✔
36
37	def test_authenticated_user_redirect_to_homepage(self):	2✔
38	request = self.factory.get(reverse("login"))	1✔
39	request.user = self.customUser	1✔
40	request.user.is_authenticated = lambda: True	1✔
41	response = login_redirect(request)	1✔
42	self.assertIsInstance(response, HttpResponseRedirect)	1✔
43	self.assertEqual(response.url, reverse("homepage"))	1✔
44
45	def test_unauthenticated_user_render_login_page(self):	2✔
46	request = self.factory.get(reverse("login"))	1✔
47	request.user = AnonymousUser()	1✔
48	response = login_redirect(request)	1✔
49	self.assertEqual(response.status_code, 200)	1✔
50	self.assertIn("Continue with Google", response.content.decode())	1✔
51
52	def test_create_custom_user(self):	2✔
53	# Create a CustomUser object
54	CustomUser.objects.create(	1✔
55	username="test",
56	email="test@test.com",
57	preferences=True, # Set preferences to True for demonstration
58	last_login=timezone.make_aware(
59	timezone.datetime(2022, 1, 1)
60	), # Set last_login to a specific datetime for demonstration
61	)
62
63	# Retrieve the created CustomUser object from the database
64	retrieved_custom_user = CustomUser.objects.get(email="test@test.com")	1✔
65
66	# Verify that the retrieved CustomUser object matches the expected values
67	self.assertEqual(retrieved_custom_user.username, "test")	1✔
68	self.assertEqual(retrieved_custom_user.email, "test@test.com")	1✔
69	self.assertEqual(retrieved_custom_user.preferences, True)	1✔
70	self.assertEqual(	1✔
71	retrieved_custom_user.last_login,
72	timezone.make_aware(timezone.datetime(2022, 1, 1)),
73	)
74
75	def test_create_user_preferences(self):	2✔
76	# Create user preferences
77	UserPreferences.objects.create(	1✔
78	user=self.customUser,
79	phone_number="1234567890",
80	address="Test Address",
81	diet="vegetarian",
82	height=170,
83	weight=150,
84	target_weight=140,
85	)
86
87	self.cuisine1 = Cuisine.objects.create(name="Chinese")	1✔
88	self.cuisine2 = Cuisine.objects.create(name="Indian")	1✔
89	self.allergy1 = Allergy.objects.create(name="Dairy")	1✔
90	self.allergy2 = Allergy.objects.create(name="Nuts")	1✔
91
92	# Retrieve the created user preferences
93	user_preferences = UserPreferences.objects.get(user=self.customUser)	1✔
94	user_preferences.cuisines.add(self.cuisine1)	1✔
95	user_preferences.allergies.add(self.allergy1)	1✔
96
97	# Check if the created user preferences match the provided data
98	self.assertEqual(user_preferences.phone_number, "1234567890")	1✔
99	self.assertEqual(user_preferences.address, "Test Address")	1✔
100	self.assertEqual(user_preferences.diet, "vegetarian")	1✔
101	self.assertEqual(user_preferences.height, 170)	1✔
102	self.assertEqual(user_preferences.weight, 150)	1✔
103	self.assertEqual(user_preferences.target_weight, 140)	1✔
104
105	# Check if cuisines and allergies are properly associated
106	self.assertIn(self.cuisine1, user_preferences.cuisines.all())	1✔
107	self.assertNotIn(self.cuisine2, user_preferences.cuisines.all())	1✔
108	self.assertIn(self.allergy1, user_preferences.allergies.all())	1✔
109	self.assertNotIn(self.allergy2, user_preferences.allergies.all())	1✔
110
111	def test_update_user_preferences(self):	2✔
112	# Create user preferences
113	user_preferences = UserPreferences.objects.create(	1✔
114	user=self.customUser,
115	phone_number="1234567890",
116	address="Test Address",
117	diet="vegetarian",
118	height=170,
119	weight=150,
120	target_weight=140,
121	)
122
123	# Update user preferences
124	user_preferences.diet = "vegan"	1✔
125	user_preferences.save()	1✔
126
127	# Retrieve the updated user preferences
128	updated_preferences = UserPreferences.objects.get(user=self.customUser)	1✔
129
130	# Check if the diet field is updated
131	self.assertEqual(updated_preferences.diet, "vegan")	1✔
132
133	def test_delete_user_preferences(self):	2✔
134	user_preferences = UserPreferences.objects.create(	1✔
135	user=self.customUser,
136	phone_number="1234567890",
137	address="Test Address",
138	diet="vegetarian",
139	height=170,
140	weight=150,
141	target_weight=140,
142	)
143
144	# Delete user preferences
145	user_preferences.delete()	1✔
146
147	# Ensure the preferences are deleted
148	with self.assertRaises(UserPreferences.DoesNotExist):	1✔
149	UserPreferences.objects.get(user=self.customUser)	1✔
150
151	def test_set_preferences_valid_data_anonymous(self):	2✔
152	data = {	1✔
153	"phone": "1234567890",
154	"address": "Test Address",
155	"diet": "vegetarian",
156	"cuisine": ["Indian", "Italian"],
157	"allergies": ["Dairy", "Nuts"],
158	"height": "170",
159	"weight": "150",
160	"targetWeight": "140",
161	}
162	request = self.factory.get(reverse("setPreferences"))	1✔
163	request.user = AnonymousUser()	1✔
164	request.data = data	1✔
165	response = set_preferences(request)	1✔
166	self.assertEqual(	1✔
167	response.status_code, 302
168	) # Redirects to login page for anonymous users
169
170	def test_set_preferences_anonymous(self):	2✔
171	request = self.factory.get(reverse("setPreferences"))	1✔
172	request.user = AnonymousUser()	1✔
173	response = set_preferences(request)	1✔
174	self.assertEqual(response.status_code, 302)	1✔
175
176	def test_set_preferences_valid_data_authenticated_set(self):	2✔
177	data = {	1✔
178	"phone": "1234567890",
179	"address": "Test Address",
180	"diet": "vegetarian",
181	"cuisine": ["Indian", "Italian"],
182	"allergies": ["Dairy", "Nuts"],
183	"height": "170",
184	"weight": "150",
185	"targetWeight": "140",
186	}
187
188	fq = RequestFactory()	1✔
189	custom_user = CustomUser.objects.create(	1✔
190	username="test", email="test@test.com", preferences="False"
191	)
192	request = fq.post(reverse("setPreferences"), data=data)	1✔
193
194	middleware = SessionMiddleware(lambda req: None)	1✔
195	middleware.process_request(request)	1✔
196	request.session.save()	1✔
197
198	request.user = custom_user	1✔
199	force_authenticate(request, user=custom_user)	1✔
200
201	request.user.is_authenticated = lambda: True	1✔
202	response = set_preferences(request)	1✔
203	self.assertTrue(request.session["preferences_updated"])	1✔
204	self.assertTrue(request.session["preferences_set"])	1✔
205	self.assertTrue(request.session["check_user_preferences"])	1✔
206	# Check if the response status code is 302
207	self.assertEqual(response.status_code, 302)	1✔
208
209	# def test_set_preferences_valid_data_authenticated_update(self):
210	# data = {
211	# 'cuisine': ['Indian'],
212	# 'allergies': ['Dairy']
213	# }
214	# fq = RequestFactory()
215	# custom_user = CustomUser.objects.create(
216	# username="test", email="test@test.com", preferences="True"
217	# )
218	# request = fq.post(reverse("setPreferences"), data=data)
219
220	# middleware = SessionMiddleware(lambda req: None)
221	# middleware.process_request(request)
222	# request.session.save()
223
224	# request.user = custom_user
225	# force_authenticate(request, user=custom_user)
226
227	# request.user.is_authenticated = lambda: True
228
229	# response = set_preferences(request)
230	# self.assertTrue(request.session['preferences_updated'])
231	# self.assertEqual(response.status_code, 302)
232
233	def test_set_preferences_invalid_data_authenticated_set(self):	2✔
234	data = {	1✔
235	"address": "Test Address",
236	"diet": "vegetarian",
237	"cuisine": ["Indian", "Italian"],
238	"allergies": ["Dairy", "Nuts"],
239	"height": "170",
240	"weight": "150",
241	"targetWeight": "140",
242	}
243	custom_user = CustomUser.objects.create(	1✔
244	username="test", email="test@test.com", preferences="False"
245	)
246	custom_user_instance = CustomUser.objects.get(email=custom_user.email)	1✔
247	request = self.factory.post(reverse("setPreferences"))	1✔
248	request.user = custom_user_instance	1✔
249	request.user.is_authenticated = lambda: True	1✔
250	request.data = data	1✔
251	response = set_preferences(request)	1✔
252	self.assertEqual(response.status_code, 400)	1✔
253
254	def test_skip_preferences_ajax_anonymous(self):	2✔
255	request = self.factory.get(reverse("skipPreferences"))	1✔
256	request.user = AnonymousUser()	1✔
257	response = skip_preferences(request)	1✔
258	self.assertEqual(response.status_code, 302)	1✔
259
260	def test_skip_preferences_ajax_authenticated(self):	2✔
261	request = self.factory.get(reverse("skipPreferences"))	1✔
262	request.user = self.customUser	1✔
263	request.user.is_authenticated = lambda: True	1✔
264	response = skip_preferences(request)	1✔
265	self.assertEqual(response.status_code, 302)	1✔
266
267	def test_preferences_unauthenticated(self):	2✔
268	# Make a GET request to the preferences view without logging in
269	request = self.factory.get(reverse("preferences"))	1✔
270	request.user = AnonymousUser()	1✔
271	response = preferences(request)	1✔
272	self.assertEqual(response.status_code, 302)	1✔
273
274	def test_preferences_authenticated_no_preferences(self):	2✔
275	# Make a GET request to the preferences view after logging in
276	custom_user = CustomUser.objects.create(username="test", email="test@test.com")	1✔
277	request = self.factory.get(reverse("preferences"))	1✔
278	request.user = custom_user	1✔
279	request.user.is_authenticated = lambda: True	1✔
280	response = preferences(request)	1✔
281	self.assertEqual(response.status_code, 200)	1✔
282	self.assertEqual(response.template_name, "users/preferences.html")	1✔
283	self.assertEqual(response.context_data["preferences"], None)	1✔
284
285	def test_preferences_authenticated_with_preferences(self):	2✔
286	UserPreferences.objects.create(	1✔
287	user=self.customUser,
288	phone_number="1234567890",
289	address="Test Address",
290	diet="Vegetarian",
291	height=170,
292	weight=60,
293	target_weight=55,
294	)
295	cuisine1 = Cuisine.objects.create(name="Chinese")	1✔
296	cuisine2 = Cuisine.objects.create(name="Italian")	1✔
297	allergy1 = Allergy.objects.create(name="Dairy")	1✔
298
299	# Retrieve the created user preferences
300	user_preferences = UserPreferences.objects.get(user=self.customUser)	1✔
301	user_preferences.cuisines.add(cuisine1)	1✔
302	user_preferences.cuisines.add(cuisine2)	1✔
303	user_preferences.allergies.add(allergy1)	1✔
304
305	request = self.factory.get(reverse("preferences"))	1✔
306	request.user = self.customUser	1✔
307	request.user.is_authenticated = lambda: True	1✔
308	response = preferences(request)	1✔
309
310	# Assert that the preferences are rendered correctly
311	self.assertEqual(response.template_name, "users/preferences.html")	1✔
312	self.assertEqual(response.status_code, 200)	1✔
313	self.assertEqual(	1✔
314	response.context_data["preferences"]["phone_number"], "1234567890"
315	)
316	self.assertEqual(	1✔
317	response.context_data["preferences"]["address"], "Test Address"
318	)
319	self.assertEqual(response.context_data["preferences"]["diet"], "Vegetarian")	1✔
320	# self.assertEqual(response.context_data['preferences']['cuisines'], ['Italian', 'Chinese'])
321	self.assertEqual(response.context_data["preferences"]["allergies"], ["Dairy"])	1✔
322	self.assertEqual(response.context_data["preferences"]["height"], 170)	1✔
323	self.assertEqual(response.context_data["preferences"]["weight"], 60)	1✔
324	self.assertEqual(response.context_data["preferences"]["target_weight"], 55)	1✔
325
326	def test_update_custom_user_existing(self):	2✔
327	# Simulate the user_logged_in event
328	user_logged_in = Signal()	×
329	user_logged_in.send(sender=self.customUser.__class__, user=self.customUser)	×
330
331	# Retrieve the CustomUser object from the database
332	custom_user = CustomUser.objects.get(email=self.customUser.email)	×
333
334	# Verify that the CustomUser's last_login is updated
335	self.assertTrue(	×
336	custom_user.last_login > timezone.now() - timezone.timedelta(seconds=1)
337	)
338
339	def test_update_custom_user_new(self):	2✔
340	customUser = CustomUser.objects.create(username="test", email="test@test.com")	×
341	user_logged_in = Signal()	×
342	# Simulate the user_logged_in event for a new user
343	user_logged_in.send(sender=customUser.__class__, user=customUser)	×
344
345	# Retrieve the CustomUser object from the database
346	custom_user = CustomUser.objects.get(email=customUser.email)	×
347
348	# Verify that a new CustomUser object is created with the correct data
349	self.assertEqual(custom_user.email, customUser.email)	×
350	self.assertEqual(custom_user.username, customUser.username)	×
351	self.assertEqual(custom_user.preferences, False)	×
352
353	def test_clean_email_unique(self):	2✔
354	# Test that clean_email method raises ValidationError for existing email
355	form_data = {	1✔
356	"username": "test_user",
357	"email": "test@example.com",
358	"password": "testpassword",
359	}
360	form = UserSignUpForm(data=form_data)	1✔
361	self.assertFalse(form.is_valid())	1✔
362	self.assertIn("email", form.errors)	1✔
363	self.assertEqual(form.errors["email"], ["Email already exists."])	1✔
364
365	def test_clean_username_unique(self):	2✔
366	# Test that clean_username method raises ValidationError for existing username
367	form_data = {	1✔
368	"username": "testuser",
369	"email": "testing@example.com",
370	"password": "testpassword",
371	}
372	form = UserSignUpForm(data=form_data)	1✔
373	self.assertFalse(form.is_valid())	1✔
374	self.assertIn("username", form.errors)	1✔
375	self.assertEqual(form.errors["username"], ["Username already exists."])	1✔
376
377	def test_update_custom_user_existing(self):	2✔
378	# CustomUser.objects.create(username=self.user.username, email=self.user.email)
379	request = self.factory.get("/")	1✔
380	request.user = self.customUser	1✔
381	middleware = SessionMiddleware(lambda req: None)	1✔
382	middleware.process_request(request)	1✔
383	request.session.save()	1✔
384
385	update_custom_user(CustomUser, self.customUser, request)	1✔
386	custom_user = CustomUser.objects.get(username=self.customUser.username)	1✔
387
388	self.assertEqual(custom_user.last_login.date(), timezone.now().date())	1✔
389	self.assertEqual(	1✔
390	request.session["check_user_preferences"], custom_user.preferences
391	)
392	self.assertEqual(request.session["username"], self.customUser.username)	1✔
393
394	def test_update_custom_user_new(self):	2✔
395	request = self.factory.get("/")	1✔
396	request.user = self.customUser	1✔
397	middleware = SessionMiddleware(lambda req: None)	1✔
398	middleware.process_request(request)	1✔
399	request.session.save()	1✔
400
401	update_custom_user(User, self.customUser, request)	1✔
402	custom_user = CustomUser.objects.get(username=self.customUser.username)	1✔
403
404	self.assertEqual(custom_user.last_login.date(), timezone.now().date())	1✔
405	self.assertEqual(request.session["username"], self.customUser.username)	1✔
406
407	@patch("users.signals.CustomUser.objects.create")	2✔
408	@freeze_time("2024-04-10 16:39:55")	2✔
409	def test_user_signed_up(self, mock_create):	2✔
410	data = {"username": "testuser", "email": "test@otherexample.com"}	1✔
411	request = self.factory.get("/")	1✔
412	middleware = SessionMiddleware(lambda req: None)	1✔
413	middleware.process_request(request)	1✔
414	request.session.save()	1✔
415
416	user_signed_up(data, request)	1✔
417
418	mock_create.assert_called_once_with(	1✔
419	username=data["username"],
420	email=data["email"],
421	preferences=False,
422	last_login=timezone.now(),
423	)
424	self.assertEqual(request.session["check_user_preferences"], "False")	1✔
425	self.assertEqual(request.session["username"], data["username"])	1✔
426
427	@freeze_time("2024-04-10 16:39:55")	2✔
428	def test_update_custom_user_new_user(self):	2✔
429	request = self.factory.get("/")	1✔
430	User.objects.create_user(	1✔
431	username="newuser", email="newuser@example.com", last_login=timezone.now()
432	)
433	request.user = User.objects.get(username="newuser")	1✔
434	middleware = SessionMiddleware(lambda req: None)	1✔
435	middleware.process_request(request)	1✔
436	request.session.save()	1✔
437
438	update_custom_user(User, request.user, request)	1✔
439	custom_user = CustomUser.objects.get(username=request.user.username)	1✔
440
441	self.assertEqual(custom_user.last_login.date(), timezone.now().date())	1✔
442	self.assertEqual(request.session["username"], request.user.username)	1✔
443
444	@freeze_time("2024-04-10 16:39:55")	2✔
445	def test_user_signed_up_no_mock(self):	2✔
446	data = {"username": "testotheruser", "email": "test@someotherexample.com"}	1✔
447	request = self.factory.get("/")	1✔
448	middleware = SessionMiddleware(lambda req: None)	1✔
449	middleware.process_request(request)	1✔
450	request.session.save()	1✔
451
452	user_signed_up(data, request)	1✔
453
454	custom_user = CustomUser.objects.get(username=data["username"])	1✔
455	self.assertEqual(custom_user.last_login.date(), timezone.now().date())	1✔
456	self.assertEqual(request.session["check_user_preferences"], "False")	1✔
457	self.assertEqual(request.session["username"], data["username"])	1✔

gcivil-nyu-org / INET-Wednesday-Spring2024-Team-1 / 342

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