class QuizSelectFormTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
def test_new_quiz_result_created_on_save(self):
quiz_select_form = QuizSelectForm(data={ 'quiz': self.quiz.id, 'name': 'J Doe'})
self.assertEqual(0, QuizResult.objects.count())
quiz_select_form.is_valid()
quiz_select_form.save()
quiz_results = QuizResult.objects.filter(name='J Doe', quiz=self.quiz)
self.assertEqual(1, len(quiz_results))
class QuizFormTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
self.quiz_result = QuizResult(name='J Doe', quiz=self.quiz)
self.quiz_result.save()
self.data = {}
for answer in self.quiz_result.answers.all():
question_text = answer.question.question
self.data['question_{0}'.format(answer.id)] = 'Yes'
def test_questions_are_populated_and_required(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
self.assertEqual(2, len(quiz_form.fields))
for key in quiz_form.fields.iterkeys():
self.assertTrue(quiz_form.fields[key].required)
def test_questions_marked_as_answered_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
quiz_form.save(self.quiz_result)
# Note: an unanswered question is represented by None
answers = self.quiz_result.answers.all()
for answer in answers:
self.assertNotEqual(None, answer.correct)
def test_quiz_completed_datetime_set_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
self.assertEqual(None, self.quiz_result.completed)
quiz_form.save(self.quiz_result)
self.assertNotEqual(None, self.quiz_result.completed)
def home_page(request):
if request.method == 'POST':
q = Question()
question_text = request.POST.get('question_text','')
ans = request.POST.get('ans','')
q.text = question_text
q.ans = ans
q.save()
return redirect('/')
questions = Question.objects.all()
return render(request, 'quiz/home.html', {'questions':questions})
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
class QuizTestCase(TestCase):
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description='Test Quiz'
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
def test_should_404_if_quiz_doesnt_exist(self):
response = self.client.get(reverse('quiz', args=(111,)))
self.assertEqual(404, response.status_code)
def test_should_redirect_home_if_quiz_is_taken(self):
quiz_result = QuizResult(
name='John Doe',
quiz=self.quiz,
completed=timezone.now()
)
quiz_result.save()
response = self.client.get(reverse('quiz', args=(quiz_result.id,)))
self.assertEqual(302, response.status_code)
def test_should_contain_form_in_context(self):
quiz_result = QuizResult(
name='John Doe',
quiz=self.quiz
)
quiz_result.save()
response = self.client.get(reverse('quiz', args=(quiz_result.id,)))
self.assertEqual(200, response.status_code)
self.assertIsNot(None, response.context['form'])
def questions(request, quiz_id):
try:
quiz = Quiz.objects.get(id = quiz_id)
except Quiz.DoesNotExist:
return ({'error' : 'Not found'}, 404)
if request.method == 'GET':
start_amount, end_amount, years, discount_rate = get_moneys(quiz)
questions = Question.objects.filter(quiz = quiz).order_by('-order')
if questions.exists():
order = questions[0].order+1
else:
order = 0
q = Question(
years = years,
start_amount = start_amount,
end_amount = end_amount,
quiz = quiz,
discount_rate = discount_rate,
order = order
)
q.save()
return q
def create_quiz_questions(user, quiz, quiz_obj):
for q in quiz_obj['questions']:
question = Question(owner=user,
type=q['question']['type'],
title=q['question']['title'])
question.save()
quiz_question = QuizQuestion(quiz=quiz, question=question, order=q['order'])
quiz_question.save()
q['id'] = quiz_question.pk
q['question']['id'] = question.pk
for prop in q['question']['props']:
if prop is not 'id':
QuestionProps(
question=question, name=prop,
value=q['question']['props'][prop]
).save()
for r in q['question']['responses']:
response = Response(
owner=user,
question=question,
title=r['title'],
score=r['score'],
order=r['order']
)
response.save()
r['id'] = response.pk
for prop in r['props']:
if prop is not 'id':
ResponseProps(
response=response, name=prop,
value=r['props'][prop]
).save()
def create_quiz_questions(user, quiz, quiz_obj ):
for q in quiz_obj['questions']:
question = Question(owner=user,
type=q['question']['type'],
title=q['question']['title'])
question.save()
quiz_question = QuizQuestion(quiz=quiz, question=question, order=q['order'])
quiz_question.save()
q['id'] = quiz_question.pk
q['question']['id'] = question.pk
for prop in q['question']['props']:
if prop is not 'id':
QuestionProps(
question=question, name=prop,
value=q['question']['props'][prop]
).save()
for r in q['question']['responses']:
response = Response(
owner=user,
question=question,
title=r['title'],
score=r['score'],
order=r['order']
)
response.save()
r['id'] = response.pk
for prop in r['props']:
if prop is not 'id':
ResponseProps(
response=response, name=prop,
value=r['props'][prop]
).save()
def post(self, request, *args, **kwargs):
file = request.data['myFile']
file_name = default_storage.save(file.name, file)
parsed_pdf = parser.from_file(file_name)
data = re.sub('[^a-zA-Z0-9-_*. ?:()!]', '', parsed_pdf['content'])
logger.error(data)
quiz = Quiz(name=data[slicer(data, "docx"):data.index("1)")] +
"- Sample")
quiz.save()
data = data[data.index("1)"):]
blocks = re.split(r'[ ](?=[0-9]+\))', data)
question_num = int(len(blocks) / 2)
for i, elem in enumerate(blocks[:question_num]):
if ("ANSWER KEY" in elem):
elem = elem[:elem.index("ANSWER KEY")]
question = elem[:elem.index("A)")]
q = Question(label=question,
quiz=quiz,
order=int(question[:question.index(")")]))
q.save()
letters = ["A", "B", "C", "D"]
for index, char in enumerate(letters):
label = ""
if index == len(letters) - 1:
label = elem[elem.index(char + ")"):]
else:
label = elem[elem.index(char +
")"):elem.index(letters[index +
1] + ")")]
Answer.objects.create(
question=q,
label=label,
is_correct=blocks[question_num + i].find(char) > -1)
return Response(QuizListSerializer(quiz).data)
def setUp(self):
self.quiz = Quiz(
name='Test Quiz',
slug='Test Quiz',
description=''
)
self.quiz.save()
self.question_a = Question(question='Test Question A', correct_answer='Yes')
self.question_a.save()
self.question_b = Question(question='Test Question B', correct_answer='No')
self.question_b.save()
self.quiz.questions.add(self.question_a)
self.quiz.questions.add(self.question_b)
self.quiz_result = QuizResult(name='J Doe', quiz=self.quiz)
self.quiz_result.save()
self.data = {}
for answer in self.quiz_result.answers.all():
question_text = answer.question.question
self.data['question_{0}'.format(answer.id)] = 'Yes'
def create_questions_to_quiz(self, quiz: Quiz) -> None:
how_many = random.randint(4, 8)
question_objs = []
questions = {f"{self.faker.sentence()}{i}?" for i in range(how_many)}
for question in questions:
question_objs.append(Question(
quiz=quiz,
question=question,
explanation=self.faker.sentence()
))
Question.objects.bulk_create(question_objs)
for question in Question.objects.filter(question__in=questions):
self.create_answers_to_question(question)
def validate(self,data):
answer=data.get("answer",None)
player=self.context.get("player")
print(player)
#player=data.get("player")
active=config.quiz_active(config)
day=config.objects.all()[0].current_day
curr_question=player[0].current_question
question=Question.objects.filter(day=day,question_no=curr_question)
result=Question.check_ans(Question,answer,question)
if result:
player[0].new_score(player)
return {
"result":result
}
def clone_question(modeladmin, request, queryset):
for obj in queryset:
new_obj = Question()
new_obj.quiz = obj.quiz
new_obj.question += "{} (kopie)".format(obj.question)
new_obj.additional_info = obj.additional_info
new_obj.image = obj.image
new_obj.save()
for answer in obj.answers.all():
print("Test", answer)
new_answer = Answer()
new_answer.answer = answer.answer
new_answer.question = new_obj
new_answer.save()
if answer == obj.right_answer:
new_obj.right_answer = new_answer
new_obj.save()
def quiz():
category = Category()
category.name = "teste_category"
category.save()
question = Question()
question.question = "test_question"
question.answer_A = "test_A"
question.answer_B = "test_B"
question.answer_C = "test_C"
question.save()
quiz = Quiz()
quiz.title = "test_quiz"
quiz.category = category
quiz.save()
quiz.question.add(question)
return quiz
def validate(self,data):
answer=data.get("answer",None)
player=self.context.get("player")
print(player)
#player=data.get("player")
active=config.quiz_active(config)
curr_config = config.current_config(config)
day=curr_config.current_day
curr_question=player[0].current_question
question=Question.objects.filter(day=day,question_no=curr_question)
result=Question.check_ans(Question,answer,question) #answer is being checked here. Resulting response is sent back
if result:
player[0].new_score(player) #if ans is correct, new score is store. Result is returned
return {
"result":result
}
def home_page(request):
if request.method == 'POST':
q = Question()
question_text = request.POST.get('question_text', '')
ans = request.POST.get('ans', '')
q.text = question_text
q.ans = ans
q.save()
return redirect('/')
questions = Question.objects.all()
return render(request, 'quiz/home.html', {'questions': questions})
def create_test():
data = request.get_json()
questions = []
for q in data['questions']:
answers = []
for answer in q['answers']:
answer = Answer(answer=answer['answer'],
is_correct=answer.get('is_correct'))
answers.append(answer)
q = Question(question=q['question'], answers=answers)
questions.append(q)
duration = data['duration']
test = Test(name=data['name'], questions=questions, duration=duration)
db.session.add(test)
db.session.commit()
return jsonify(test.to_dict()), 201
def post(self, request):
player = UserScore.objects.filter(user=request.user)[0]
print(player.name)
answer = request.data.get("answer", None)
print(player)
active = config.quiz_active(config)
curr_config = config.current_config(config)
if active:
day = curr_config.current_day
curr_day = player.today
curr_question = player.current_question
if curr_day > day:
response = {"quiz_finished": True}
return Response(response)
if curr_day < day:
player.today = day
player.current_question = 1
curr_day = player.today
curr_question = player.current_question
player.save()
question = Question.objects.filter(day=day,
question_no=curr_question)
result = Question.check_ans(Question, answer, question)
quiz_ended = False
if result:
player.new_score(player)
UserScore.lboardSave(UserScore)
curr_day = player.today
if curr_day > curr_config.current_day:
quiz_ended = True
response = {
'status_code': status.HTTP_200_OK,
'result': result,
'quiz_finished': quiz_ended
}
else:
response = {"error": "quiz has ended"}
return Response(response)
def test_saving_and_retrieving_questions(self):
quiz_ = Quiz()
quiz_.save()
first_question = Question()
first_question.question_text = 'The first (ever) quiz Question'
first_question.quiz = quiz_
first_question.save()
second_question = Question()
second_question.question_text = 'Question the second'
second_question.quiz = quiz_
second_question.save()
saved_quiz = Quiz.objects.first()
self.assertEqual(saved_quiz, quiz_)
saved_questions = Question.objects.all()
self.assertEqual(saved_questions.count(), 2)
first_saved_question = saved_questions[0]
second_saved_question = saved_questions[1]
self.assertEqual(first_saved_question.question_text,
'The first (ever) quiz Question')
self.assertEqual(first_saved_question.quiz, quiz_)
self.assertEqual(second_saved_question.question_text,
'Question the second')
self.assertEqual(second_saved_question.quiz, quiz_)
def test_string_representation(self):
question = Question(text='question text')
assert str(question) == question.text
def test_can_save_question_to_database(self):
first_question = Question()
first_question.text = '1 + 1 = 2'
first_question.ans = 'True'
first_question.save()
saved_items = Question.objects.all()
self.assertEqual(saved_items.count(), 1)
second_question = Question()
second_question.text = '1 = 2'
second_question.ans = 'False'
second_question.save()
saved_items = Question.objects.all()
self.assertEqual(saved_items.count(), 2)
self.assertEqual(Question.objects.all()[0].text, '1 + 1 = 2')
self.assertEqual(Question.objects.all()[1].text, '1 = 2')
def add_questions(request, quizid):
user = request.user
if user.is_admin():
quiz = Quiz.objects.get(quiz_id=quizid)
if request.method == 'POST':
q_type = strip_tags(request.POST.get('type'))
ques = Question()
ques.quiz = quiz
ques.type = strip_tags(request.POST.get('type'))
ques.marks = strip_tags(request.POST.get('marks'))
ques.level = strip_tags(request.POST.get('level'))
ques.time_limit = strip_tags(request.POST.get('time_limit'))
ques.question = strip_tags(request.POST.get('question'))
ques.negative = strip_tags(request.POST.get('negative'))
# if Image is uploaded
img = request.FILES.get('image')
if img:
ques.image = img
else:
print("\n\n\n\nNo File was uploaded\n\n\n\n")
# if Code is added
code = request.POST.get('code')
if code:
ques.code = code
# if Question is subjective
if q_type == 's':
ques.subjective_answer = strip_tags(
request.POST.get('subjective_answer'))
# Question is objective
else:
ques.option_A = strip_tags(request.POST.get('option_a'))
ques.option_B = strip_tags(request.POST.get('option_b'))
ques.option_C = strip_tags(request.POST.get('option_c'))
ques.option_D = strip_tags(request.POST.get('option_d'))
ques.correct = strip_tags(request.POST.get('correct'))
ques.save()
return JsonResponse({'kudos': "kudos"})
# GET the page
else:
return render(request, 'add_questions.html', {
'title': 'Add Questions',
'quiz_data': quiz
})
# User Does not has sufficient permissions
else:
messages.info(
request,
'You do not have the permissions required to edit this quiz')
return redirect('home')
def home_page(request):
new_item_text = Question(question_text='item_text')
return render(request, 'home.html', {
'new_item_text': request.POST.get('item_text', ''),
})
def update_quiz(request, id):
data = json.loads(request.raw_post_data)
quiz = Quiz.objects.get(id=id)
quiz.title = data.get("title", quiz.title)
quiz.subtitle = data.get("subtitle", quiz.subtitle)
quiz.text = data.get("text", quiz.text)
quiz.email = data.get("email", quiz.email)
qids = []
for qd in data.get("questions", []):
qid = qd.get("id", None)
if not qid:
q = Question(index=qd['index'],
text=qd.get('text', ''),
choices=json.dumps(qd.get('choices', {})),
explanation=qd.get('explanation'),
correct=qd.get('correct', ''))
q.save()
qids.append(q.id)
quiz.questions.add(q)
else:
q = Question.objects.get(id=qid)
q.text = qd.get('text', '')
q.choices = json.dumps(qd['choices'])
q.correct = qd.get('correct', '')
q.explanation = qd.get('explanation')
q.index = qd['index']
qids.append(q.id)
q.save()
# Look for questions that don't exist and delete them
for q in Question.objects.filter(quiz=quiz):
if not q.id in qids:
q.delete()
quiz.save()
return retrieve_quiz(request, id)
def update_quiz(request, id):
data = json.loads(request.raw_post_data)
quiz = Quiz.objects.get(id=id)
quiz.title = data.get("title", quiz.title)
quiz.subtitle = data.get("subtitle", quiz.subtitle)
quiz.text = data.get("text", quiz.text)
quiz.email = data.get("email", quiz.email)
qids = []
for qd in data.get("questions",[]):
qid = qd.get("id", None)
if not qid:
q = Question(
index=qd['index'],
text=qd.get('text',''),
choices=json.dumps(qd.get('choices',{})),
explanation=qd.get('explanation'),
correct=qd.get('correct','')
)
q.save()
qids.append(q.id)
quiz.questions.add(q)
else:
q = Question.objects.get(id=qid)
q.text = qd.get('text','')
q.choices = json.dumps(qd['choices'])
q.correct = qd.get('correct','')
q.explanation = qd.get('explanation')
q.index = qd['index']
qids.append(q.id)
q.save()
# Look for questions that don't exist and delete them
for q in Question.objects.filter(quiz=quiz):
if not q.id in qids:
q.delete()
quiz.save()
return retrieve_quiz(request, id)
def add_question(request):
if request.method == "POST":
question = request.POST.get("question")
option1 = request.POST.get("option1")
option2 = request.POST.get("option2")
option3 = request.POST.get("option3")
option4 = request.POST.get("option4")
answer = request.POST.get("answer")
exam = request.POST.get("exam")
q = Question()
q.question = question
q.option1 = option1
q.option2 = option2
q.option3 = option3
q.option4 = option4
q.answer = answer
q.exam = Exam.objects.get(pk=int(exam))
q.save()
return HttpResponse("success")
def test_question_title_no_quiz_props(self):
question = Question(title='{"fi": "kysymykseni"}')
question.save()
self.assertEqual("kysymykseni", question.get_title('fi'))
self.assertEqual("kysymykseni", str(question))
def update(self, instance, validated_data, user=None):
question = Question(id=instance.id, **validated_data)
question.save()
return question
def get_quiz(request):
"""
Return the non-archived quiz if the resourceLinkId and contextId pair exists, if not, then check whether the resourceLinkId exists. If it
does, then a new quiz is to be created which would be copy of the latest non archived version of the quiz with given resourceLinkId
return new quiz.
"""
live_quiz = Quiz.objects.filter(
consumer_key=lti.get_oauth_consumer_key(request),
resourceLinkId=lti.get_resource_link_id(request),
contextId=lti.get_context_id(request))
if live_quiz.exists():
return live_quiz.latest()
# The resourceLinkId and the contextId pair doesn't exists, check whether the resourceLinkId exists.
if Quiz.objects.filter(
consumer_key=lti.get_oauth_consumer_key(request),
resourceLinkId=lti.get_resource_link_id(request)).exists():
# The quiz link is being migrated to another Context (new course term), hence the non-archived
# latest quiz with same resourceLinkId has to be copied over as a new Quiz.
quiz = create_new_quiz(request)
latest_quiz = Quiz.objects.filter(
consumer_key=lti.get_oauth_consumer_key(request),
resourceLinkId=lti.get_resource_link_id(request)).latest()
# copy all the settings of the latest quiz associated with the RESOURCE LINK ID.
quiz_settings = QuizSettings.objects.get(quiz=quiz)
quiz_settings.duration = latest_quiz.duration
quiz_settings.timeBetweenAttempt = latest_quiz.timeBetweenAttempt
quiz_settings.maxAttempts = latest_quiz.maxAttempts
quiz_settings.graded = latest_quiz.graded
quiz_settings.save()
#TODO: Copy all the questions , doing it manually to avoid any useless trouble: is it the right way?
questions = get_questions_by_quiz(latest_quiz)
for question in questions:
new_question = Question()
new_question.quiz = question.quiz # change the quiz to the new quiz
new_question.question_type = question.question_type
new_question.serial_number = question.serial_number
new_question.question_weight = question.question_weight
new_question.statement = question.statement
new_question.options_data = question.options_data
new_question.expected_response = question.expected_response
new_question.other_data = question.other_data
new_question.published = question.published
new_question.save()
return quiz
# The quiz doesn't exists for associated request! Return False
return False
for line_number, line in enumerate(data):
line = line.split('\t')
if line[0] == '':
continue
if line[1].startswith('id: +'):
quiz_title = line[0]
current_quiz = Quiz(user_id=1,
category='not set',
difficulty=1,
description='No description')
current_quiz.name = quiz_title
current_quiz.save()
continue
quiz_question = line[0]
question_list = []
current_question = Question(quiz=current_quiz, text=quiz_question)
current_question.save()
question_list.append(current_question)
answer_list = []
for it, answer in enumerate(line[1:]):
if answer == '':
is_result = True
for correct in [l for l in line[it + 3:] if l != '\n']:
good_answer = correct
for ans in answer_list:
if ans.text == good_answer:
ans.is_correct = True
ans.save()
for q in question_list:
q.quiz = current_quiz
