def submit_response(self, question_id, answer_form=None):
"""Updates assessmentParts map to insert an item response.
answer_form is None indicates that the current response is to be cleared
"""
if answer_form is None:
response = {
'missingResponse': NULL_RESPONSE,
'itemId': str(question_id)
}
else:
response = dict(answer_form._my_map)
response['submissionTime'] = DateTime.utcnow()
try:
response['isCorrect'] = self._get_item(
question_id).is_response_correct(
Response(osid_object_map=response,
runtime=self._runtime,
proxy=self._proxy))
except (errors.IllegalState, errors.NotFound):
response['isCorrect'] = None
response['submissionTime'] = DateTime.utcnow()
question_map = self._get_question_map(
question_id) # will raise NotFound()
if ('missingResponse' in question_map['responses'][0] and
question_map['responses'][0]['missingResponse'] == UNANSWERED):
question_map['responses'] = [] # clear unanswered response
question_map['responses'].insert(0, response)
self._save()
def test_chapter_sequential_can_clear_start_date(self):
for genus_type in [
'fake.Genus%3Achapter%40ODL.MIT.EDU',
'fake.Genus%3Asequential%40ODL.MIT.EDU'
]:
form = EdXCompositionFormRecord(self.osid_object_form)
form.my_osid_object_form._my_map['genusTypeId'] = genus_type
default_start_date = form._start_date_metadata[
'default_date_time_values'][0]
default_start_date = DateTime(
year=default_start_date.year,
month=default_start_date.month,
day=default_start_date.day,
hour=default_start_date.hour,
minute=default_start_date.minute,
second=default_start_date.second,
microsecond=default_start_date.microsecond)
future_date = datetime.datetime.utcnow() + datetime.timedelta(
days=4)
start_date = DateTime(year=future_date.year,
month=future_date.month,
day=future_date.day,
hour=future_date.hour,
minute=future_date.minute,
second=future_date.second,
microsecond=future_date.microsecond)
form.set_start_date(start_date)
assert form.my_osid_object_form._my_map['startDate'] == start_date
form.clear_start_date()
assert form.my_osid_object_form._my_map[
'startDate'] == default_start_date
def date_time_test_wrapper(request):
utcnow = DateTime.utcnow()
request.cls.date_time = DateTime(year=utcnow.year,
month=utcnow.month,
day=utcnow.day,
hour=utcnow.hour,
minute=utcnow.minute,
second=utcnow.second,
microsecond=utcnow.microsecond)
def test_match_timestamp(self):
"""Tests match_timestamp"""
start_date = DateTime.utcnow()
end_date = DateTime.utcnow()
assert 'timestamp' not in self.query._query_terms
self.query.match_timestamp(start_date, end_date, True)
assert self.query._query_terms['timestamp'] == {
'$gte': start_date,
'$lte': end_date
}
def test_set_timestamp(self):
"""Tests set_timestamp"""
if not is_never_authz(self.service_config):
test_time = DateTime.utcnow()
# By default log entries have this set, so can't use the templated test
assert self.form._my_map['timestamp'] is not None
self.form.set_timestamp(test_time)
assert self.form._my_map['timestamp'] == test_time
with pytest.raises(errors.InvalidArgument):
self.form.set_timestamp(True)
def now_map():
now = DateTime.utcnow()
return {
'year': now.year,
'month': now.month,
'day': now.day,
'hour': now.hour,
'minute': now.minute,
'second': now.second,
'microsecond': now.microsecond,
}
def now_map():
now = DateTime.utcnow()
return {
'year': now.year,
'month': now.month,
'day': now.day,
'hour': now.hour,
'minute': now.minute,
'second': now.second,
'microsecond': now.microsecond,
}
def test_chapter_and_sequential_can_get_start_date(self):
for genus_type in [
'fake.Genus%3Achapter%40ODL.MIT.EDU',
'fake.Genus%3Asequential%40ODL.MIT.EDU'
]:
utcnow = DateTime.utcnow()
self.obj_map['startDate'] = utcnow
self.obj_map['genusTypeId'] = genus_type
osid_object = OsidObject(
object_name='REPOSITORY',
osid_object_map=self.obj_map,
runtime=self.rm._provider_manager._runtime)
composition = EdXCompositionRecord(osid_object)
result = composition.start_date
assert isinstance(result, DateTime)
assert result == utcnow
def get_questions(self, answered=None, honor_sequential=True, update=True):
"""gets all available questions for this section
if answered == False: only return next unanswered question
if answered == True: only return next answered question
if answered in None: return next question whether answered or not
if honor_sequential == True: only return questions if section or part
is set to sequential items
"""
def update_question_list():
"""Supportive function to aid readability of _get_questions."""
latest_question_response = question_map['responses'][0]
question_answered = False
# take missingResponse == UNANSWERED or NULL_RESPONSE as an unanswered question
if 'missingResponse' not in latest_question_response:
question_answered = True
if answered is None or answered == question_answered:
question_list.append(
self.get_question(question_map=question_map))
return question_answered
prev_question_answered = True
question_list = []
if update:
self._update_questions() # Make sure questions list is current
for question_map in self._my_map['questions']:
if self._is_question_sequential(question_map) and honor_sequential:
if prev_question_answered:
prev_question_answered = update_question_list()
else:
update_question_list()
if self._my_map['actualStartTime'] is None:
self._my_map['actualStartTime'] = DateTime.utcnow()
return QuestionList(question_list,
runtime=self._runtime,
proxy=self._proxy)
def test_chapter_sequential_can_set_start_date(self):
for genus_type in [
'fake.Genus%3Achapter%40ODL.MIT.EDU',
'fake.Genus%3Asequential%40ODL.MIT.EDU'
]:
form = EdXCompositionFormRecord(self.osid_object_form)
form.my_osid_object_form._my_map['genusTypeId'] = genus_type
future_date = datetime.datetime.utcnow() + datetime.timedelta(
days=4)
start_date = DateTime(year=future_date.year,
month=future_date.month,
day=future_date.day,
hour=future_date.hour,
minute=future_date.minute,
second=future_date.second,
microsecond=future_date.microsecond)
assert isinstance(form.my_osid_object_form._my_map['startDate'],
DateTime)
assert start_date != form.my_osid_object_form._my_map['startDate']
form.set_start_date(start_date)
assert form.my_osid_object_form._my_map['startDate'] == start_date
def finish(self):
"""Declare this section finished"""
self._my_map['over'] = True # finished == over?
self._my_map['completionTime'] = DateTime.utcnow()
self._save()
def get_first_question(self):
if self._my_map['actualStartTime'] is None:
self._my_map['actualStartTime'] = DateTime.utcnow()
return self.get_question(question_map=self._my_map['questions'][0])