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

/TutorFilter/tests.py

from django.test import TestCase
from django.urls import reverse
from django.contrib.auth.models import User
from TutorRegister.models import (
    ProfileT,
    Expertise,
    UserType,
    Availability,
    TutoringSession,
)
from django.test import Client
from datetime import datetime, timedelta
from .forms import TutoringSessionRequestForm
import json


class TutorFilterTest(TestCase):
    @classmethod
    def setUpTestData(self):
        # Set up data for the whole TestCase
        # Create expertise, profile, and other necessary objects here
        self.testuser = User.objects.create_user(
            username="testuser@example.com",
            password="testpassword",
        )
        Expertise.objects.create(user=self.testuser, subject="math")
        ProfileT.objects.create(
            user=self.testuser,
            preferred_mode="remote",
            grade="freshman",
            zip="12345",
            salary_min=50,
        )
        UserType.objects.filter(user=self.testuser).update(has_profile_complete=True)
        # Assign the expertise to the user somehow, according to your model structure

    def test_filter_tutors(self):
        # Simulate a GET request with query parameters
        form_data = {
            "preferred_mode": "remote",
            "grade": "freshman",
            "expertise": "math",
            "zipcode": "12345",
            "salary_max": 60,
        }
        # form = TutorFilterForm(data=form_data)
        response = self.client.get(
            reverse("TutorFilter:filter_tutors"),
            form_data,
        )
        # Check if the response is 200 OK
        self.assertEqual(response.status_code, 200)
        # Check if the response context contains the expected user
        users_in_context = response.context["users"]
        self.assertTrue(any(user.user == self.testuser for user in users_in_context))

    def test_filter_tutors2(self):
        c = Client()
        # Simulate a GET request with query parameters
        form_data2 = {
            "preferred_mode": "remote",
            "grade": "grad",
            "expertise": "math",
            "zipcode": "11111",
            "salary_max": 20,
        }
        # form = TutorFilterForm(data=form_data)
        response2 = c.post(reverse("TutorFilter:filter_tutors"), form_data2)
        # Check if the response is 200 OK
        self.assertEqual(response2.status_code, 200)
        response2 = c.get(
            reverse("TutorFilter:filter_tutors"),
            form_data2,
        )
        # Check if the response context contains the expected user
        self.assertEqual(len(response2.context["users"]), 0)


class TutoringSessionTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.user = User.objects.create_user(
            username="tutor@test.com", password="password123"
        )
        cls.user.usertype.user_type = "tutor"
        cls.user.usertype.save()
        cls.url = reverse("Dashboard:tutor_profile")
        ProfileT.objects.create(
            user=cls.user,
            fname="Test",
            lname="User",
            gender="prefernottosay",
            major="Computer Science",
            zip="00000",
            grade="grad",
            preferred_mode="remote",
            intro="ello \nyello \njelo",
        )
        Availability.objects.create(
            user=cls.user,
            day_of_week="monday",
            start_time=datetime.strptime("09:00", "%H:%M").time(),
            end_time=datetime.strptime("17:00", "%H:%M").time(),
        )
        Expertise.objects.create(user=cls.user, subject="math")
        User.objects.create_user(username="student", password="studentpassword")

    def setUp(self):
        self.client = Client()
        self.client.login(username="student", password="studentpassword")

    def test_request_tutoring_session_get(self):
        response = self.client.get(reverse("TutorFilter:request", args=[self.user.id]))
        self.assertEqual(response.status_code, 200)
        self.assertIsInstance(response.context["form"], TutoringSessionRequestForm)

    def test_request_tutoring_session_post_valid(self):
        data = {
            "tutoring_mode": "remote",
            "subject": "math",
            "date": "2024-04-01",
            "offering_rate": 50,
            "message": "Looking forward to the session!",
            "selected_timeslots": json.dumps([{"start": "09:00", "end": "09:30"}]),
        }
        response = self.client.post(
            reverse("TutorFilter:request", args=[self.user.id]), data
        )
        self.assertEqual(response.status_code, 302)
        self.assertTrue(TutoringSession.objects.exists())

    def test_request_tutoring_session_post_invalid(self):
        data = {
            "tutoring_mode": "",
            "subject": "Math",
            "date": "2024-03-25",
            "offering_rate": 50,
            "message": "Looking forward to the session!",
            "selected_timeslots": json.dumps([{"start": "09:00", "end": "09:30"}]),
        }
        response = self.client.post(
            reverse("TutorFilter:request", args=[self.user.id]), data
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(TutoringSession.objects.exists())

    def test_get_available_times(self):
        response = self.client.post(
            reverse(
                "TutorFilter:get-available-times", args=[self.user.id, "2024-04-01"]
            )
        )
        self.assertEqual(response.status_code, 200)
        response_data = json.loads(response.content)
        self.assertIn("available_slots", response_data)
        self.assertIn("day", response_data)

1	from django.test import TestCase	2✔
2	from django.urls import reverse	2✔
3	from django.contrib.auth.models import User	2✔
4	from TutorRegister.models import (	2✔
5	ProfileT,
6	Expertise,
7	UserType,
8	Availability,
9	TutoringSession,
10	)
11	from django.test import Client	2✔
12	from datetime import datetime, timedelta	2✔
13	from .forms import TutoringSessionRequestForm	2✔
14	import json	2✔
15
16
17	class TutorFilterTest(TestCase):	2✔
18	@classmethod	2✔
19	def setUpTestData(self):	2✔
20	# Set up data for the whole TestCase
21	# Create expertise, profile, and other necessary objects here
22	self.testuser = User.objects.create_user(	2✔
23	username="testuser@example.com",
24	password="testpassword",
25	)
26	Expertise.objects.create(user=self.testuser, subject="math")	2✔
27	ProfileT.objects.create(	2✔
28	user=self.testuser,
29	preferred_mode="remote",
30	grade="freshman",
31	zip="12345",
32	salary_min=50,
33	)
34	UserType.objects.filter(user=self.testuser).update(has_profile_complete=True)	2✔
35	# Assign the expertise to the user somehow, according to your model structure
36
37	def test_filter_tutors(self):	2✔
38	# Simulate a GET request with query parameters
39	form_data = {	2✔
40	"preferred_mode": "remote",
41	"grade": "freshman",
42	"expertise": "math",
43	"zipcode": "12345",
44	"salary_max": 60,
45	}
46	# form = TutorFilterForm(data=form_data)
47	response = self.client.get(	2✔
48	reverse("TutorFilter:filter_tutors"),
49	form_data,
50	)
51	# Check if the response is 200 OK
52	self.assertEqual(response.status_code, 200)	2✔
53	# Check if the response context contains the expected user
54	users_in_context = response.context["users"]	2✔
55	self.assertTrue(any(user.user == self.testuser for user in users_in_context))	2✔
56
57	def test_filter_tutors2(self):	2✔
58	c = Client()	2✔
59	# Simulate a GET request with query parameters
60	form_data2 = {	2✔
61	"preferred_mode": "remote",
62	"grade": "grad",
63	"expertise": "math",
64	"zipcode": "11111",
65	"salary_max": 20,
66	}
67	# form = TutorFilterForm(data=form_data)
68	response2 = c.post(reverse("TutorFilter:filter_tutors"), form_data2)	2✔
69	# Check if the response is 200 OK
70	self.assertEqual(response2.status_code, 200)	2✔
71	response2 = c.get(	2✔
72	reverse("TutorFilter:filter_tutors"),
73	form_data2,
74	)
75	# Check if the response context contains the expected user
76	self.assertEqual(len(response2.context["users"]), 0)	2✔
77
78
79	class TutoringSessionTests(TestCase):	2✔
80	@classmethod	2✔
81	def setUpTestData(cls):	2✔
82	cls.user = User.objects.create_user(	2✔
83	username="tutor@test.com", password="password123"
84	)
85	cls.user.usertype.user_type = "tutor"	2✔
86	cls.user.usertype.save()	2✔
87	cls.url = reverse("Dashboard:tutor_profile")	2✔
88	ProfileT.objects.create(	2✔
89	user=cls.user,
90	fname="Test",
91	lname="User",
92	gender="prefernottosay",
93	major="Computer Science",
94	zip="00000",
95	grade="grad",
96	preferred_mode="remote",
97	intro="ello \nyello \njelo",
98	)
99	Availability.objects.create(	2✔
100	user=cls.user,
101	day_of_week="monday",
102	start_time=datetime.strptime("09:00", "%H:%M").time(),
103	end_time=datetime.strptime("17:00", "%H:%M").time(),
104	)
105	Expertise.objects.create(user=cls.user, subject="math")	2✔
106	User.objects.create_user(username="student", password="studentpassword")	2✔
107
108	def setUp(self):	2✔
109	self.client = Client()	2✔
110	self.client.login(username="student", password="studentpassword")	2✔
111
112	def test_request_tutoring_session_get(self):	2✔
113	response = self.client.get(reverse("TutorFilter:request", args=[self.user.id]))	2✔
114	self.assertEqual(response.status_code, 200)	2✔
115	self.assertIsInstance(response.context["form"], TutoringSessionRequestForm)	2✔
116
117	def test_request_tutoring_session_post_valid(self):	2✔
118	data = {	2✔
119	"tutoring_mode": "remote",
120	"subject": "math",
121	"date": "2024-04-01",
122	"offering_rate": 50,
123	"message": "Looking forward to the session!",
124	"selected_timeslots": json.dumps([{"start": "09:00", "end": "09:30"}]),
125	}
126	response = self.client.post(	2✔
127	reverse("TutorFilter:request", args=[self.user.id]), data
128	)
NEW 129	self.assertEqual(response.status_code, 302)	1✔
NEW 130	self.assertTrue(TutoringSession.objects.exists())	1✔
131
132	def test_request_tutoring_session_post_invalid(self):	2✔
133	data = {	2✔
134	"tutoring_mode": "",
135	"subject": "Math",
136	"date": "2024-03-25",
137	"offering_rate": 50,
138	"message": "Looking forward to the session!",
139	"selected_timeslots": json.dumps([{"start": "09:00", "end": "09:30"}]),
140	}
141	response = self.client.post(	2✔
142	reverse("TutorFilter:request", args=[self.user.id]), data
143	)
144	self.assertEqual(response.status_code, 200)	2✔
145	self.assertFalse(TutoringSession.objects.exists())	2✔
146
147	def test_get_available_times(self):	2✔
148	response = self.client.post(	2✔
149	reverse(
150	"TutorFilter:get-available-times", args=[self.user.id, "2024-04-01"]
151	)
152	)
153	self.assertEqual(response.status_code, 200)	2✔
154	response_data = json.loads(response.content)	2✔
155	self.assertIn("available_slots", response_data)	2✔
156	self.assertIn("day", response_data)	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