def test_points_percentage(self):
fs = factories.FlowSessionFactory(participation=self.participation,
points=None)
self.assertEqual(fs.points_percentage(), None)
fs = factories.FlowSessionFactory(participation=self.participation,
points=20,
max_points=None)
self.assertEqual(fs.points_percentage(), None)
fs = factories.FlowSessionFactory(participation=self.participation,
points=20,
max_points=20)
self.assertEqual(fs.points_percentage(), 100)
def test_unicode(self):
fs1 = factories.FlowSessionFactory(participation=self.participation)
fs2 = factories.FlowSessionFactory(participation=self.participation)
self.assertNotEqual(str(fs1), str(fs2))
fs3 = factories.FlowSessionFactory(user=None,
course=self.course,
participation=None)
fs4 = factories.FlowSessionFactory(user=None,
course=self.course,
participation=None)
self.assertNotEqual(str(fs3), str(fs4))
def setUp(self):
super(FlowPageVisitGradeTest, self).setUp()
self.user = factories.UserFactory()
self.participation = factories.ParticipationFactory(course=self.course,
user=self.user)
fs = factories.FlowSessionFactory(participation=self.participation)
self.fpdata = factories.FlowPageDataFactory(flow_session=fs)
def test_submit_history_failure_no_perm(self):
# student have no pperm to view ta's submit history
ta_flow_session = factories.FlowSessionFactory(
participation=self.ta_participation)
resp = self.get_page_submit_history_by_ordinal(
page_ordinal=1, flow_session_id=ta_flow_session.id)
self.assertEqual(resp.status_code, 403)
def test_grade_history_failure_no_perm(self):
ta_flow_session = factories.FlowSessionFactory(
participation=self.ta_participation)
# no pperm to view other's grade_history
resp = self.c.post(
self.get_page_grade_history_url_by_ordinal(
page_ordinal=1, flow_session_id=ta_flow_session.pk))
self.assertEqual(resp.status_code, 403)
def setUp(self):
super(GradingChangeTest, self).setUp()
self.user = factories.UserFactory()
self.participation = factories.ParticipationFactory(course=self.course,
user=self.user)
self.flow_session = factories.FlowSessionFactory(
participation=self.participation)
self.opportunity1 = factories.GradingOpportunityFactory(
course=self.course, identifier="gopp1")
self.opportunity2 = factories.GradingOpportunityFactory(
course=self.course, identifier="gopp2")
def test_already_locked_down(self):
factories.FlowSessionFactory(participation=self.student_participation,
flow_id=self.flow_id)
session = self.c.session
session["relate_session_locked_to_exam_flow_session_pk"] = 1
session.save()
resp = self.c.get(self.course_page_url)
self.assertRedirects(resp,
self.get_view_start_flow_url(self.flow_id),
fetch_redirect_response=False)
def test_flow_session_has_no_participation(self):
null_participation_flow_session = factories.FlowSessionFactory(
course=self.course, participation=None, user=None)
url = self.get_page_grading_url_by_ordinal(
page_ordinal=1,
flow_session_id=null_participation_flow_session.pk,
)
with self.temporarily_switch_to_user(
self.instructor_participation.user):
resp = self.c.get(url)
self.assertEqual(resp.status_code, 400)
def test_fail_course_not_matched(self):
another_course = factories.CourseFactory(identifier="another-course")
another_course_fs = factories.FlowSessionFactory(
participation=factories.ParticipationFactory(
course=another_course))
token = self.create_token()
resp = self.c.get(self.get_get_flow_session_content_url(
flow_session_id=another_course_fs.id),
HTTP_AUTHORIZATION="Token %i_%s" %
(token.id, self.default_token_hash_str))
self.assertEqual(resp.status_code, 403)
def test_not_ok_view_flow_page(self):
fs = factories.FlowSessionFactory(
participation=self.student_participation, flow_id=self.flow_id)
resp = self.c.get(
self.get_page_url_by_ordinal(0, flow_session_id=fs.pk))
self.assertRedirects(resp,
reverse("relate-list_available_exams"),
fetch_redirect_response=False)
self.assertAddMessageCallCount(1)
self.assertAddMessageCalledWith(
"Access to flows in an exams-only facility "
"is only granted if the flow is locked down. "
"To do so, add 'lock_down_as_exam_session' to "
"your flow's access permissions.")
def test_flow_session_course_not_matching(self):
another_course = factories.CourseFactory(identifier="another-course")
some_user = factories.UserFactory()
his_participation = factories.ParticipationFactory(
course=another_course, user=some_user)
his_flow_session = factories.FlowSessionFactory(
course=another_course, participation=his_participation)
url = self.get_page_grading_url_by_ordinal(
page_ordinal=1,
course_identifier=self.course.identifier,
flow_session_id=his_flow_session.pk)
with self.temporarily_switch_to_user(
self.instructor_participation.user):
resp = self.c.get(url)
self.assertEqual(resp.status_code, 400)
def setUpTestData(cls): # noqa
super(CourseAdminSessionRelatedMixin, cls).setUpTestData()
course1_session = factories.FlowSessionFactory.create(
participation=cls.course1_student_participation2,
flow_id="001-linalg-recap")
course1_flow_page_data = factories.FlowPageDataFactory.create(
flow_session=course1_session)
factories.FlowPageVisitFactory.create(page_data=course1_flow_page_data)
course2_sessions = factories.FlowSessionFactory.create_batch(
size=3, participation=cls.course2_student_participation)
cls.course2_session4 = factories.FlowSessionFactory(course=cls.course2,
participation=None,
user=None)
for session in course2_sessions:
course2_flow_page_data = factories.FlowPageDataFactory.create(
flow_session=session, )
factories.FlowPageVisitFactory.create(
page_data=course2_flow_page_data, answer={"answer": "hi"})
# a flow session without page_ordinal
course2_non_ordinal_flow_page_data = factories.FlowPageDataFactory(
flow_session=cls.course2_session4, page_ordinal=None)
factories.FlowPageVisitFactory(
page_data=course2_non_ordinal_flow_page_data)
course1_sessions = models.FlowSession.objects.filter(
course=cls.course1)
cls.course1_session_count = course1_sessions.count()
course1_visits = models.FlowPageVisit.objects.filter(
flow_session__course=cls.course1)
cls.course1_visits_count = course1_visits.count()
cls.course1_visits_has_answer_count = course1_visits.filter(
answer__isnull=False).count()
cls.course2_sessions = models.FlowSession.objects.filter(
course=cls.course2)
cls.course2_session_count = cls.course2_sessions.count()
course2_visits = models.FlowPageVisit.objects.filter(
flow_session__course=cls.course2)
cls.course2_visits_count = course2_visits.count()
cls.course2_visits_has_answer_count = course2_visits.filter(
answer__isnull=False).count()
def test_result(self):
flow_ids = ["c", "b", "a"]
for flow_id in flow_ids:
factories.FlowSessionFactory.create_batch(
size=2,
participation=self.student_participation,
flow_id=flow_id)
another_course = factories.CourseFactory(identifier="another-course")
another_participation = factories.ParticipationFactory(
course=another_course)
# This make sure other courses' flow_id won't be included
factories.FlowSessionFactory(participation=another_participation,
flow_id="d")
resp = self.get_flow_list_view()
self.assertEqual(resp.status_code, 200)
self.assertResponseContextEqual(resp, "flow_ids", sorted(flow_ids))
def test_last_activity(self):
fs = factories.FlowSessionFactory(participation=self.participation)
fpdata = factories.FlowPageDataFactory(flow_session=fs)
factories.FlowPageVisitFactory(page_data=fpdata,
answer=None,
visit_time=datetime(2019,
1,
1,
tzinfo=pytz.UTC))
factories.FlowPageVisitFactory(page_data=fpdata,
answer=None,
visit_time=datetime(2019,
1,
2,
tzinfo=pytz.UTC))
self.assertEqual(fs.last_activity(), None)
fpv = factories.FlowPageVisitFactory(
page_data=fpdata,
answer={"answer": "hi"},
visit_time=datetime(2018, 12, 31, tzinfo=pytz.UTC))
self.assertEqual(fs.last_activity(), fpv.visit_time)
def test_unicode(self):
fs = factories.FlowSessionFactory(participation=self.participation)
fpdata = factories.FlowPageDataFactory(flow_session=fs)
self.assertIsNotNone(str(fpdata))
def test_ok_views(self):
# we only test ta participation
from course.auth import make_sign_in_key
# make sign in key for a user
u = factories.UserFactory(first_name="foo",
last_name="bar",
status=constants.user_status.unconfirmed)
sign_in_key = make_sign_in_key(u)
u.sign_in_key = sign_in_key
u.save()
self.c.force_login(self.ta_participation.user)
my_session = factories.FlowSessionFactory(
participation=self.ta_participation, flow_id=self.flow_id)
with override_settings(RELATE_SIGN_IN_BY_USERNAME_ENABLED=True):
for url, args, kwargs, code_or_redirect in [
("relate-sign_in_choice", [], {}, 200),
("relate-sign_in_by_email", [], {}, 200),
("relate-sign_in_stage2_with_token", [u.pk,
sign_in_key], {}, "/"),
("relate-sign_in_by_user_pw", [], {}, 200),
("relate-impersonate", [], {}, 200),
# because not we are testing get, while stop_impersonating view
# doesn't allow get, if it return 403 instead of 302
# we think it passed test.
("relate-stop_impersonating", [], {}, 403),
("relate-check_in_for_exam", [], {}, 200),
("relate-list_available_exams", [], {}, 200),
("relate-view_start_flow", [], {
"course_identifier": self.course.identifier,
"flow_id": self.flow_id
}, 200),
("relate-view_resume_flow", [], {
"course_identifier": self.course.identifier,
"flow_session_id": my_session.pk
},
self.get_page_url_by_ordinal(0,
flow_session_id=my_session.pk)),
("relate-user_profile", [], {}, 200),
("relate-logout", [], {}, "/"),
("relate-set_pretend_facilities", [], {}, 200),
]:
with self.subTest(url=url):
if "sign_in" in url:
switch_to = None
else:
switch_to = self.ta_participation.user
with self.temporarily_switch_to_user(switch_to):
resp = self.c.get(
reverse(url, args=args, kwargs=kwargs))
try:
code = int(code_or_redirect)
self.assertEqual(resp.status_code, code)
except ValueError:
self.assertRedirects(resp,
code_or_redirect,
fetch_redirect_response=False)
