def test_validate_regrade_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
self.answerpaper.save()
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 200
self.answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
questions='1|2|3',
question_paper=self.question_paper,
start_time='2014-06-13 12:20:19.791297',
end_time='2014-06-13 12:50:19.791297',
user_ip=self.ip)
self.answerpaper.questions_answered = '1'
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_case_sensitive_string_incorrect_answer(self):
# Given
string_answer = "hello, earth!"
answer = Answer(question=self.question2, answer=string_answer)
answer.save()
self.answerpaper.answers.add(answer)
# When
json_data = None
result = self.answerpaper.validate_answer(string_answer,
self.question2, json_data)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=answer.id)
regrade_answer.answer = "Hello, EARTH!"
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
answer = self.answerpaper.answers.filter(
question=self.question2).last()
self.assertEqual(answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(answer.marks, 1)
self.assertTrue(answer.correct)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
questions='1|2|3',
question_paper=self.question_paper,
start_time='2014-06-13 12:20:19.791297',
end_time='2014-06-13 12:50:19.791297',
user_ip=self.ip)
self.answerpaper.questions_answered = '1'
self.attempted_papers = AnswerPaper.objects.filter(question_paper=self.question_paper,
user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer", correct=True, marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer", correct=False, marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1,2,3])
self.start_time = datetime.now()
self.end_time = self.start_time + timedelta(minutes=20)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip)
self.attempted_papers = AnswerPaper.objects.filter(question_paper=self.question_paper,
user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer", correct=True, marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer", correct=False, marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_case_sensitive_string_incorrect_answer(self):
# Given
string_answer = "hello, earth!"
answer = Answer(question=self.question2, answer=string_answer)
answer.save()
self.answerpaper.answers.add(answer)
# When
json_data = None
result = self.answerpaper.validate_answer(string_answer,
self.question2, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=answer.id)
regrade_answer.answer = "Hello, EARTH!"
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
answer = self.answerpaper.answers.filter(
question=self.question2).last()
self.assertEqual(answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(answer.marks, 1)
self.assertTrue(answer.correct)
def test_float_incorrect_answer(self):
# Given
float_answer = 99.8
self.answer = Answer(
question=self.question1,
answer=float_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(float_answer, self.question1,
json_data)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 99.9
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
def test_validate_regrade_arrange_correct_answer(self):
# Given
arrange_answer = [self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
self.answer = Answer(question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
# Try regrade with wrong data structure
# When
regrade_answer.answer = 1
regrade_answer.save()
details = self.answerpaper.regrade(self.question1.id)
err_msg = dedent("""\
User: {0}; Quiz: {1}; Question: {2}.
{3} answer not a list.""".format(
self.user.username,
self.quiz.description,
self.question1.summary,
self.question1.type
) )
self.assertFalse(details[0])
self.assertEqual(details[1], err_msg)
# Try regrade with incorrect answer
# When
regrade_answer.answer = [self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
regrade_answer.save()
# Then
details = self.answerpaper.regrade(self.question1.id)
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_case_insensitive_string_incorrect_answer(self):
# Given
string_answer = "hello, mars!"
answer = Answer(question=self.question1,answer=string_answer)
answer.save()
self.answerpaper.answers.add(answer)
# When
json_data = None
result = self.answerpaper.validate_answer(string_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
answer.correct = True
answer.marks = 1
answer.answer = "hello, earth!"
answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
answer = self.answerpaper.answers.filter(question=self.question1)\
.last()
self.assertTrue(details[0])
self.assertEqual(answer.marks, 1)
self.assertTrue(answer.correct)
def test_validate_regrade_arrange_correct_answer(self):
# Given
arrange_answer = [
self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
self.answer = Answer(
question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(
arrange_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
# Try regrade with wrong data structure
# When
regrade_answer.answer = 1
regrade_answer.save()
details = self.answerpaper.regrade(self.question1.id)
self.assertFalse(details[0])
self.assertIn("arrange answer not a list", details[1])
# Try regrade with incorrect answer
# When
regrade_answer.answer = [
self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
regrade_answer.save()
# Then
details = self.answerpaper.regrade(self.question1.id)
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_case_sensitive_string_correct_answer(self):
# Given
string_answer = "Hello, EARTH!"
answer = Answer(question=self.question2, answer=string_answer)
answer.save()
self.answerpaper.answers.add(answer)
# When
json_data = None
result = self.answerpaper.validate_answer(string_answer,
self.question2, json_data)
# Then
self.assertTrue(result['success'])
def test_case_insensitive_string_incorrect_answer(self):
# Given
string_answer = "hello, mars!"
answer = Answer(question=self.question1, answer=string_answer)
answer.save()
self.answerpaper.answers.add(answer)
# When
json_data = None
result = self.answerpaper.validate_answer(string_answer,
self.question1, json_data)
# Then
self.assertFalse(result['success'])
def test_validate_and_regrade_mcq_question(self):
# Given
mcq_answer = 'a'
self.answer = Answer(question=self.question2,
answer=mcq_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
correct, result = self.answerpaper.validate_answer(mcq_answer,
self.question2, json_data)
# Then
self.assertTrue(correct)
self.assertTrue(result['success'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 'b'
self.answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question2).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_float_incorrect_answer(self):
# Given
float_answer = 99.8
self.answer = Answer(question=self.question1,
answer=float_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(float_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 99.9
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
def test_validate_regrade_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
self.answerpaper.save()
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 200
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def skip(request, q_id, next_q=None, attempt_num=None, questionpaper_id=None):
user = request.user
paper = get_object_or_404(AnswerPaper, user=request.user, attempt_number=attempt_num,
question_paper=questionpaper_id)
question = get_object_or_404(Question, pk=q_id)
if request.method == 'POST' and question.type == 'code':
user_code = request.POST.get('answer')
new_answer = Answer(question=question, answer=user_code,
correct=False, skipped=True)
new_answer.save()
paper.answers.add(new_answer)
if next_q is None:
next_q = paper.skip(q_id) if paper.skip(q_id) else question
else:
next_q = get_object_or_404(Question, pk=next_q)
return show_question(request, next_q, paper)
def test_mcc_incorrect_answer(self):
# Given
mcc_answer = ['b']
self.answer = Answer(
question=self.question3,
answer=mcc_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcc_answer, self.question3,
json_data)
# Then
self.assertFalse(result['success'])
def test_integer_incorrect_answer(self):
# Given
float_answer = 99.8
self.answer = Answer(
question=self.question1,
answer=float_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(float_answer, self.question1,
json_data)
# Then
self.assertFalse(result['success'])
def test_validate_regrade_arrange_correct_answer(self):
# Given
arrange_answer = [self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
self.answer = Answer(question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
# Try regrade with wrong data structure
# When
regrade_answer.answer = 1
regrade_answer.save()
details = self.answerpaper.regrade(self.question1.id)
err_msg = dedent("""\
User: {0}; Quiz: {1}; Question: {2}.
{3} answer not a list.""".format(
self.user.username,
self.quiz.description,
self.question1.summary,
self.question1.type
))
self.assertFalse(details[0])
self.assertEqual(details[1], err_msg)
# Try regrade with incorrect answer
# When
regrade_answer.answer = [self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
regrade_answer.save()
# Then
details = self.answerpaper.regrade(self.question1.id)
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(
question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(
integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
def test_validate_and_regrade_mcq_question(self):
# Given
mcq_answer = 'a'
self.answer = Answer(
question=self.question2,
answer=mcq_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
correct, result = self.answerpaper.validate_answer(
mcq_answer, self.question2, json_data)
# Then
self.assertTrue(correct)
self.assertTrue(result['success'])
self.assertEqual(result['error'], 'Correct answer')
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 'b'
self.answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question2).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1, 2, 3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_validate_and_regrade_mcc_correct_answer(self):
# Given
mcc_answer = ['a']
self.answer = Answer(
question=self.question3,
answer=mcc_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcc_answer, self.question3,
json_data)
# Then
self.assertTrue(result['success'])
self.assertEqual(result['error'], ['Correct answer'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = ['a', 'b']
self.answer.save()
# When
details = self.answerpaper.regrade(self.question3.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question3).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_arrange_incorrect_answer(self):
# Given
arrange_answer = [self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
self.answer = Answer(question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = [self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1,2,3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
self.question1 = self.questions.get(id=1)
self.question2 = self.questions.get(id=2)
self.question3 = self.questions.get(id=3)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip
)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper,
user=self.user
)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True, marks=1,
error=json.dumps([])
)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0,
error=json.dumps(['error1', 'error2'])
)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
self.question1.language = 'python'
self.question1.test_case_type = 'standardtestcase'
self.question1.save()
self.question2.language = 'python'
self.question2.type = 'mcq'
self.question2.test_case_type = 'mcqtestcase'
self.question2.save()
self.question3.language = 'python'
self.question3.type = 'mcc'
self.question3.test_case_type = 'mcqtestcase'
self.question3.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert add(1, 3) == 4',
type = 'standardtestcase'
)
self.assertion_testcase.save()
self.mcq_based_testcase = McqTestCase(
options = 'a',
question=self.question2,
correct = True,
type = 'mcqtestcase'
)
self.mcq_based_testcase.save()
self.mcc_based_testcase = McqTestCase(
question=self.question3,
options = 'a',
correct = True,
type = 'mcqtestcase'
)
self.mcc_based_testcase.save()
def test_validate_and_regrade_mcc_question(self):
# Given
mcc_answer = ['a']
self.answer = Answer(question=self.question3,
answer=mcc_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
correct, result = self.answerpaper.validate_answer(mcc_answer,
self.question3, json_data)
# Then
self.assertTrue(correct)
self.assertTrue(result['success'])
self.assertEqual(result['error'], ['Correct answer'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = ['a', 'b']
self.answer.save()
# When
details = self.answerpaper.regrade(self.question3.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question3).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_and_regrade_mcq_question(self):
# Given
mcq_answer = 'a'
self.answer = Answer(question=self.question2,
answer=mcq_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
correct, result = self.answerpaper.validate_answer(mcq_answer,
self.question2, json_data)
# Then
self.assertTrue(correct)
self.assertTrue(result['success'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 'b'
self.answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question2).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.get_questions()
num_questions = len(questions)
self.assertSequenceEqual(list(questions), list(self.questions))
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time, self.start_time)
self.assertEqual(self.answerpaper.status, 'inprogress')
def test_questions(self):
# Test questions_left() method of Answer Paper
self.assertEqual(self.answerpaper.questions_left(), 3)
# Test current_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 1)
# Test completed_question() method of Answer Paper
question = self.answerpaper.completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
# Test next_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 2)
# When
next_question_id = self.answerpaper.next_question(current_question.id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 3)
# Given, here question is already answered
current_question_id = 1
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Given, wrong question id
current_question_id = 12
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Given, last question in the list
current_question_id = 3
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Test get_questions_answered() method
# When
questions_answered = self.answerpaper.get_questions_answered()
# Then
self.assertEqual(questions_answered.count(), 1)
self.assertSequenceEqual(questions_answered, [self.questions[0]])
# When
questions_unanswered = self.answerpaper.get_questions_unanswered()
# Then
self.assertEqual(questions_unanswered.count(), 2)
self.assertSequenceEqual(questions_unanswered,
[self.questions[1], self.questions[2]])
# Test completed_question and next_question
# When all questions are answered
current_question = self.answerpaper.completed_question(2)
# Then
self.assertEqual(self.answerpaper.questions_left(), 1)
self.assertEqual(current_question.id, 3)
# When
current_question = self.answerpaper.completed_question(3)
# Then
self.assertEqual(self.answerpaper.questions_left(), 0)
self.assertTrue(current_question is None)
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is None)
def test_update_marks(self):
""" Test update_marks method of AnswerPaper"""
self.answerpaper.update_marks('inprogress')
self.assertEqual(self.answerpaper.status, 'inprogress')
self.assertTrue(self.answerpaper.is_attempt_inprogress())
self.answerpaper.update_marks()
self.assertEqual(self.answerpaper.status, 'completed')
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
self.assertEqual(self.answerpaper.percent, 33.33)
self.assertTrue(self.answerpaper.passed)
self.assertFalse(self.answerpaper.is_attempt_inprogress())
def test_set_end_time(self):
current_time = timezone.now()
self.answerpaper.set_end_time(current_time)
self.assertEqual(self.answerpaper.end_time,current_time)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = list(answered.values())[0][0]
first_answer_obj = first_answer['answer']
self.assertEqual(first_answer_obj.answer, 'Demo answer')
self.assertTrue(first_answer_obj.correct)
self.assertEqual(len(answered), 2)
def test_is_answer_correct(self):
self.assertTrue(self.answerpaper.is_answer_correct(self.questions[0]))
self.assertFalse(self.answerpaper.is_answer_correct(self.questions[1]))
def test_get_previous_answers(self):
answers = self.answerpaper.get_previous_answers(self.questions[0])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_right)
answers = self.answerpaper.get_previous_answers(self.questions[1])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_wrong)
def test_set_marks (self):
self.answer_wrong.set_marks(0.5)
self.assertEqual(self.answer_wrong.marks, 0.5)
self.answer_wrong.set_marks(10.0)
self.assertEqual(self.answer_wrong.marks,1.0)
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1,2,3])
self.start_time = datetime.now()
self.end_time = self.start_time + timedelta(minutes=20)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip
)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper,
user=self.user
)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True, marks=1
)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0
)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.get_questions()
num_questions = len(questions)
self.assertSequenceEqual(list(questions), list(self.questions))
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time, self.start_time)
self.assertEqual(self.answerpaper.status, 'inprogress')
def test_questions(self):
# Test questions_left() method of Answer Paper
self.assertEqual(self.answerpaper.questions_left(), 3)
# Test current_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 1)
# Test completed_question() method of Answer Paper
question = self.answerpaper.completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
# Test skip() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 2)
next_question_id = self.answerpaper.skip(current_question.id)
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 3)
questions_answered = self.answerpaper.get_questions_answered()
self.assertEqual(questions_answered.count(), 1)
self.assertSequenceEqual(questions_answered, [self.questions[0]])
questions_unanswered = self.answerpaper.get_questions_unanswered()
self.assertEqual(questions_unanswered.count(), 2)
self.assertSequenceEqual(questions_unanswered,
[self.questions[1], self.questions[2]])
def test_update_marks(self):
""" Test update_marks method of AnswerPaper"""
self.answerpaper.update_marks('inprogress')
self.assertEqual(self.answerpaper.status, 'inprogress')
self.assertTrue(self.answerpaper.is_attempt_inprogress())
self.answerpaper.update_marks()
self.assertEqual(self.answerpaper.status, 'completed')
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
self.assertEqual(self.answerpaper.percent, 33.33)
self.assertTrue(self.answerpaper.passed)
self.assertFalse(self.answerpaper.is_attempt_inprogress())
def test_set_end_time(self):
current_time = datetime.now()
self.answerpaper.set_end_time(current_time)
self.assertEqual(self.answerpaper.end_time,current_time)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = answered.values()[0][0]
self.assertEqual(first_answer.answer, 'Demo answer')
self.assertTrue(first_answer.correct)
self.assertEqual(len(answered), 2)
def test_is_answer_correct(self):
self.assertTrue(self.answerpaper.is_answer_correct(self.questions[0]))
self.assertFalse(self.answerpaper.is_answer_correct(self.questions[1]))
def test_get_previous_answers(self):
answers = self.answerpaper.get_previous_answers(self.questions[0])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_right)
answers = self.answerpaper.get_previous_answers(self.questions[1])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_wrong)
def test_set_marks (self):
self.answer_wrong.set_marks(0.5)
self.assertEqual(self.answer_wrong.marks, 0.5)
self.answer_wrong.set_marks(10.0)
self.assertEqual(self.answer_wrong.marks,1.0)
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1, 2, 3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
self.question1 = self.questions.get(id=1)
self.question2 = self.questions.get(id=2)
self.question3 = self.questions.get(id=3)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1,
error=json.dumps([]))
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0,
error=json.dumps(['error1', 'error2']))
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
self.question1.language = 'python'
self.question1.test_case_type = 'standardtestcase'
self.question1.save()
self.question2.language = 'python'
self.question2.type = 'mcq'
self.question2.test_case_type = 'mcqtestcase'
self.question2.save()
self.question3.language = 'python'
self.question3.type = 'mcc'
self.question3.test_case_type = 'mcqtestcase'
self.question3.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert add(1, 3) == 4',
type='standardtestcase')
self.assertion_testcase.save()
self.mcq_based_testcase = McqTestCase(options='a',
question=self.question2,
correct=True,
type='mcqtestcase')
self.mcq_based_testcase.save()
self.mcc_based_testcase = McqTestCase(question=self.question3,
options='a',
correct=True,
type='mcqtestcase')
self.mcc_based_testcase.save()
def test_validate_and_regrade_mcc_correct_answer(self):
# Given
mcc_answer = ['a']
self.answer = Answer(
question=self.question3,
answer=mcc_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcc_answer, self.question3,
json_data)
# Then
self.assertTrue(result['success'])
self.assertEqual(result['error'], ['Correct answer'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = ['a', 'b']
self.answer.save()
# When
details = self.answerpaper.regrade(self.question3.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question3).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_and_regrade_mcq_correct_answer(self):
# Given
mcq_answer = 'a'
self.answer = Answer(
question=self.question2,
answer=mcq_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcq_answer, self.question2,
json_data)
# Then
self.assertTrue(result['success'])
self.answer.correct = True
self.answer.marks = 1
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 'b'
self.answer.save()
# When
details = self.answerpaper.regrade(self.question2.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question2).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_mcq_incorrect_answer(self):
# Given
mcq_answer = 'b'
self.answer = Answer(
question=self.question2,
answer=mcq_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcq_answer, self.question2,
json_data)
# Then
self.assertFalse(result['success'])
def test_mcc_incorrect_answer(self):
# Given
mcc_answer = ['b']
self.answer = Answer(
question=self.question3,
answer=mcc_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(mcc_answer, self.question3,
json_data)
# Then
self.assertFalse(result['success'])
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.get_questions()
num_questions = len(questions)
self.assertSequenceEqual(list(questions), list(self.questions))
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time, self.start_time)
self.assertEqual(self.answerpaper.status, 'inprogress')
def test_questions(self):
# Test questions_left() method of Answer Paper
self.assertEqual(self.answerpaper.questions_left(), 3)
# Test current_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 1)
# Test completed_question() method of Answer Paper
question = self.answerpaper.add_completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
# Test next_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 2)
# When
next_question_id = self.answerpaper.next_question(current_question.id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 3)
# Given, here question is already answered
current_question_id = 1
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Given, wrong question id
current_question_id = 12
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 1)
# Given, last question in the list
current_question_id = 3
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 1)
# Test get_questions_answered() method
# When
questions_answered = self.answerpaper.get_questions_answered()
# Then
self.assertEqual(questions_answered.count(), 1)
self.assertSequenceEqual(questions_answered, [self.questions[0]])
# When
questions_unanswered = self.answerpaper.get_questions_unanswered()
# Then
self.assertEqual(questions_unanswered.count(), 2)
self.assertSequenceEqual(questions_unanswered,
[self.questions[1], self.questions[2]])
# Test completed_question and next_question
# When all questions are answered
current_question = self.answerpaper.add_completed_question(2)
# Then
self.assertEqual(self.answerpaper.questions_left(), 1)
self.assertEqual(current_question.id, 3)
# When
current_question = self.answerpaper.add_completed_question(3)
# Then
self.assertEqual(self.answerpaper.questions_left(), 0)
self.assertTrue(current_question is None)
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is None)
def test_update_marks(self):
""" Test update_marks method of AnswerPaper"""
self.answerpaper.update_marks('inprogress')
self.assertEqual(self.answerpaper.status, 'inprogress')
self.assertTrue(self.answerpaper.is_attempt_inprogress())
self.answerpaper.update_marks()
self.assertEqual(self.answerpaper.status, 'completed')
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
self.assertEqual(self.answerpaper.percent, 33.33)
self.assertTrue(self.answerpaper.passed)
self.assertFalse(self.answerpaper.is_attempt_inprogress())
def test_set_end_time(self):
current_time = timezone.now()
self.answerpaper.set_end_time(current_time)
self.assertEqual(self.answerpaper.end_time, current_time)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = list(answered.values())[0][0]
first_answer_obj = first_answer['answer']
self.assertEqual(first_answer_obj.answer, 'Demo answer')
self.assertTrue(first_answer_obj.correct)
self.assertEqual(len(answered), 2)
def test_is_answer_correct(self):
self.assertTrue(self.answerpaper.is_answer_correct(self.questions[0]))
self.assertFalse(self.answerpaper.is_answer_correct(self.questions[1]))
def test_get_previous_answers(self):
answers = self.answerpaper.get_previous_answers(self.questions[0])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_right)
answers = self.answerpaper.get_previous_answers(self.questions[1])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_wrong)
def test_set_marks(self):
self.answer_wrong.set_marks(0.5)
self.assertEqual(self.answer_wrong.marks, 0.5)
self.answer_wrong.set_marks(10.0)
self.assertEqual(self.answer_wrong.marks, 1.0)
class ArrangeQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Course
self.course = Course.objects.get(name="Python Course 100")
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz,
total_marks=1.0)
# Creating User
self.user = User.objects.get(username='******')
# Creating Question
self.question1 = Question.objects.create(summary='arrange1',
points=1.0,
user=self.user)
self.question1.language = 'python'
self.question1.type = "arrange"
self.question1.description = "Arrange alphabets in ascending order"
self.question1.test_case_type = 'arrangetestcase'
self.question1.save()
# Creating answerpaper
self.answerpaper = AnswerPaper.objects.create(
user=self.user,
user_ip='101.0.0.1',
course=self.course,
start_time=timezone.now(),
question_paper=self.question_paper,
end_time=timezone.now() + timedelta(minutes=5),
attempt_number=1)
self.answerpaper.questions.add(self.question1)
self.answerpaper.save()
# For question
self.arrange_testcase_1 = ArrangeTestCase(
question=self.question1,
options="A",
type='arrangetestcase',
)
self.arrange_testcase_1.save()
self.testcase_1_id = self.arrange_testcase_1.id
self.arrange_testcase_2 = ArrangeTestCase(
question=self.question1,
options="B",
type='arrangetestcase',
)
self.arrange_testcase_2.save()
self.testcase_2_id = self.arrange_testcase_2.id
self.arrange_testcase_3 = ArrangeTestCase(
question=self.question1,
options="C",
type='arrangetestcase',
)
self.arrange_testcase_3.save()
self.testcase_3_id = self.arrange_testcase_3.id
@classmethod
def tearDownClass(self):
self.question1.delete()
self.answerpaper.delete()
def test_validate_regrade_arrange_correct_answer(self):
# Given
arrange_answer = [
self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
self.answer = Answer(
question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(
arrange_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
# Try regrade with wrong data structure
# When
regrade_answer.answer = 1
regrade_answer.save()
details = self.answerpaper.regrade(self.question1.id)
self.assertFalse(details[0])
self.assertIn("arrange answer not a list", details[1])
# Try regrade with incorrect answer
# When
regrade_answer.answer = [
self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
regrade_answer.save()
# Then
details = self.answerpaper.regrade(self.question1.id)
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_arrange_incorrect_answer(self):
# Given
arrange_answer = [
self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
self.answer = Answer(
question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1, json_data)
# Then
self.assertFalse(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = [
self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
class IntegerQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Course
self.course = Course.objects.get(name="Python Course 100")
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz)
# Creating User
self.user = User.objects.get(username='******')
# Creating Question
self.question1 = Question.objects.create(summary='int1', points=1,
type='code', user=self.user)
self.question1.language = 'python'
self.question1.type = "integer"
self.question1.test_case_type = 'integertestcase'
self.question1.description = 'sum of 12+13?'
self.question1.save()
# Creating answerpaper
self.answerpaper = AnswerPaper.objects.create(
user=self.user, user_ip='101.0.0.1', start_time=timezone.now(),
question_paper=self.question_paper, course=self.course,
end_time=timezone.now()+timedelta(minutes=5), attempt_number=1
)
self.answerpaper.questions.add(self.question1)
self.answerpaper.save()
# For question
self.integer_based_testcase = IntegerTestCase(question=self.question1,
correct=25,
type='integertestcase',
)
self.integer_based_testcase.save()
@classmethod
def tearDownClass(self):
self.question1.delete()
self.answerpaper.delete()
def test_validate_regrade_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
self.answerpaper.save()
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 200
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_integer_incorrect_answer(self):
# Given
integer_answer = 26
self.answer = Answer(question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 25
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
class ArrangeQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Course
self.course = Course.objects.get(name="Python Course 100")
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz,
total_marks=1.0)
# Creating User
self.user = User.objects.get(username='******')
# Creating Question
self.question1 = Question.objects.create(summary='arrange1',
points=1.0,
user=self.user
)
self.question1.language = 'python'
self.question1.type = "arrange"
self.question1.description = "Arrange alphabets in ascending order"
self.question1.test_case_type = 'arrangetestcase'
self.question1.save()
# Creating answerpaper
self.answerpaper = AnswerPaper.objects.create(
user=self.user, user_ip='101.0.0.1', course=self.course,
start_time=timezone.now(), question_paper=self.question_paper,
end_time=timezone.now()+timedelta(minutes=5), attempt_number=1
)
self.answerpaper.questions.add(self.question1)
self.answerpaper.save()
# For question
self.arrange_testcase_1 = ArrangeTestCase(question=self.question1,
options="A",
type='arrangetestcase',
)
self.arrange_testcase_1.save()
self.testcase_1_id = self.arrange_testcase_1.id
self.arrange_testcase_2 = ArrangeTestCase(question=self.question1,
options="B",
type='arrangetestcase',
)
self.arrange_testcase_2.save()
self.testcase_2_id = self.arrange_testcase_2.id
self.arrange_testcase_3 = ArrangeTestCase(question=self.question1,
options="C",
type='arrangetestcase',
)
self.arrange_testcase_3.save()
self.testcase_3_id = self.arrange_testcase_3.id
@classmethod
def tearDownClass(self):
self.question1.delete()
self.answerpaper.delete()
def test_validate_regrade_arrange_correct_answer(self):
# Given
arrange_answer = [self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
self.answer = Answer(question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
# Try regrade with wrong data structure
# When
regrade_answer.answer = 1
regrade_answer.save()
details = self.answerpaper.regrade(self.question1.id)
err_msg = dedent("""\
User: {0}; Quiz: {1}; Question: {2}.
{3} answer not a list.""".format(
self.user.username,
self.quiz.description,
self.question1.summary,
self.question1.type
))
self.assertFalse(details[0])
self.assertEqual(details[1], err_msg)
# Try regrade with incorrect answer
# When
regrade_answer.answer = [self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
regrade_answer.save()
# Then
details = self.answerpaper.regrade(self.question1.id)
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_arrange_incorrect_answer(self):
# Given
arrange_answer = [self.testcase_1_id,
self.testcase_3_id,
self.testcase_2_id,
]
self.answer = Answer(question=self.question1,
answer=arrange_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(arrange_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade with wrong answer
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = [self.testcase_1_id,
self.testcase_2_id,
self.testcase_3_id,
]
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1, 2, 3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
self.question1 = self.questions.get(id=1)
self.question2 = self.questions.get(id=2)
self.question3 = self.questions.get(id=3)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1,
error=json.dumps([]))
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0,
error=json.dumps(['error1', 'error2']))
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
self.question1.language = 'python'
self.question1.test_case_type = 'standardtestcase'
self.question1.save()
self.question2.language = 'python'
self.question2.type = 'mcq'
self.question2.test_case_type = 'mcqtestcase'
self.question2.save()
self.question3.language = 'python'
self.question3.type = 'mcc'
self.question3.test_case_type = 'mcqtestcase'
self.question3.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert add(1, 3) == 4',
type='standardtestcase')
self.assertion_testcase.save()
self.mcq_based_testcase = McqTestCase(options='a',
question=self.question2,
correct=True,
type='mcqtestcase')
self.mcq_based_testcase.save()
self.mcc_based_testcase = McqTestCase(question=self.question3,
options='a',
correct=True,
type='mcqtestcase')
self.mcc_based_testcase.save()
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1, 2, 3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.get_questions()
num_questions = len(questions)
self.assertSequenceEqual(list(questions), list(self.questions))
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time, self.start_time)
self.assertEqual(self.answerpaper.status, 'inprogress')
def test_questions(self):
# Test questions_left() method of Answer Paper
self.assertEqual(self.answerpaper.questions_left(), 3)
# Test current_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 1)
# Test completed_question() method of Answer Paper
question = self.answerpaper.completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
# Test next_question() method of Answer Paper
current_question = self.answerpaper.current_question()
self.assertEqual(current_question.id, 2)
# When
next_question_id = self.answerpaper.next_question(current_question.id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 3)
# Given, here question is already answered
current_question_id = 1
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Given, wrong question id
current_question_id = 12
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Given, last question in the list
current_question_id = 3
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id.id, 2)
# Test get_questions_answered() method
# When
questions_answered = self.answerpaper.get_questions_answered()
# Then
self.assertEqual(questions_answered.count(), 1)
self.assertSequenceEqual(questions_answered, [self.questions[0]])
# When
questions_unanswered = self.answerpaper.get_questions_unanswered()
# Then
self.assertEqual(questions_unanswered.count(), 2)
self.assertSequenceEqual(questions_unanswered,
[self.questions[1], self.questions[2]])
# Test completed_question and next_question
# When all questions are answered
current_question = self.answerpaper.completed_question(2)
# Then
self.assertEqual(self.answerpaper.questions_left(), 1)
self.assertEqual(current_question.id, 3)
# When
current_question = self.answerpaper.completed_question(3)
# Then
self.assertEqual(self.answerpaper.questions_left(), 0)
self.assertTrue(current_question is None)
# When
next_question_id = self.answerpaper.next_question(current_question_id)
# Then
self.assertTrue(next_question_id is None)
def test_update_marks(self):
""" Test update_marks method of AnswerPaper"""
self.answerpaper.update_marks('inprogress')
self.assertEqual(self.answerpaper.status, 'inprogress')
self.assertTrue(self.answerpaper.is_attempt_inprogress())
self.answerpaper.update_marks()
self.assertEqual(self.answerpaper.status, 'completed')
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
self.assertEqual(self.answerpaper.percent, 33.33)
self.assertTrue(self.answerpaper.passed)
self.assertFalse(self.answerpaper.is_attempt_inprogress())
def test_set_end_time(self):
current_time = timezone.now()
self.answerpaper.set_end_time(current_time)
self.assertEqual(self.answerpaper.end_time, current_time)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = answered.values()[0][0]
self.assertEqual(first_answer.answer, 'Demo answer')
self.assertTrue(first_answer.correct)
self.assertEqual(len(answered), 2)
def test_is_answer_correct(self):
self.assertTrue(self.answerpaper.is_answer_correct(self.questions[0]))
self.assertFalse(self.answerpaper.is_answer_correct(self.questions[1]))
def test_get_previous_answers(self):
answers = self.answerpaper.get_previous_answers(self.questions[0])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_right)
answers = self.answerpaper.get_previous_answers(self.questions[1])
self.assertEqual(answers.count(), 1)
self.assertTrue(answers[0], self.answer_wrong)
def test_set_marks(self):
self.answer_wrong.set_marks(0.5)
self.assertEqual(self.answer_wrong.marks, 0.5)
self.answer_wrong.set_marks(10.0)
self.assertEqual(self.answer_wrong.marks, 1.0)
class FloatQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz)
#Creating User
self.user = User.objects.get(username='******')
#Creating Question
self.question1 = Question.objects.create(summary='flt1', points=1,
type='code', user=self.user)
self.question1.language = 'python'
self.question1.type = "float"
self.question1.test_case_type = 'floattestcase'
self.question1.save()
#Creating answerpaper
self.answerpaper = AnswerPaper.objects.get(question_paper\
=self.question_paper)
self.answerpaper.attempt_number = 1
self.answerpaper.questions.add(self.question1)
self.answerpaper.save()
# For question
self.float_based_testcase = FloatTestCase(question=self.question1,
correct=100,
error_margin=0.1,
type = 'floattestcase',
)
self.float_based_testcase.save()
@classmethod
def tearDownClass(self):
self.question1.delete()
def test_validate_regrade_float_correct_answer(self):
# Given
float_answer = 99.9
self.answer = Answer(question=self.question1,
answer=float_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(float_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 0.0
self.answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_float_incorrect_answer(self):
# Given
float_answer = 99.8
self.answer = Answer(question=self.question1,
answer=float_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(float_answer,
self.question1, json_data
)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
self.answer.correct = True
self.answer.marks = 1
self.answer.answer = 99.9
self.answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(question=self.question1
).last()
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
self.questions = Question.objects.filter(id__in=[1,2,3])
self.start_time = timezone.now()
self.end_time = self.start_time + timedelta(minutes=20)
self.question1 = self.questions.get(id=1)
self.question2 = self.questions.get(id=2)
self.question3 = self.questions.get(id=3)
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
question_paper=self.question_paper,
start_time=self.start_time,
end_time=self.end_time,
user_ip=self.ip
)
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper,
user=self.user
)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
self.answerpaper.questions.add(*self.questions)
self.answerpaper.questions_unanswered.add(*self.questions)
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True, marks=1,
error=json.dumps([])
)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0,
error=json.dumps(['error1', 'error2'])
)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
self.question1.language = 'python'
self.question1.test_case_type = 'standardtestcase'
self.question1.save()
self.question2.language = 'python'
self.question2.type = 'mcq'
self.question2.test_case_type = 'mcqtestcase'
self.question2.save()
self.question3.language = 'python'
self.question3.type = 'mcc'
self.question3.test_case_type = 'mcqtestcase'
self.question3.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert add(1, 3) == 4',
type = 'standardtestcase'
)
self.assertion_testcase.save()
self.mcq_based_testcase = McqTestCase(
options = 'a',
question=self.question2,
correct = True,
type = 'mcqtestcase'
)
self.mcq_based_testcase.save()
self.mcc_based_testcase = McqTestCase(
question=self.question3,
options = 'a',
correct = True,
type = 'mcqtestcase'
)
self.mcc_based_testcase.save()
class IntegerQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz)
#Creating User
self.user = User.objects.get(username='******')
#Creating Question
self.question1 = Question.objects.create(summary='int1',
points=1,
type='code',
user=self.user)
self.question1.language = 'python'
self.question1.type = "integer"
self.question1.test_case_type = 'integertestcase'
self.question1.description = 'sum of 12+13?'
self.question1.save()
#Creating answerpaper
self.answerpaper = AnswerPaper.objects.get(question_paper\
=self.question_paper)
self.answerpaper.attempt_number = 1
self.answerpaper.save()
# For question
self.integer_based_testcase = IntegerTestCase(
question=self.question1,
correct=25,
type='integertestcase',
)
self.integer_based_testcase.save()
@classmethod
def tearDownClass(self):
self.question1.delete()
def test_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(
question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(
integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
def test_integer_incorrect_answer(self):
# Given
integer_answer = 26
self.answer = Answer(
question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1, json_data)
# Then
self.assertFalse(result['success'])
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
questions='1|2|3',
question_paper=self.question_paper,
start_time='2014-06-13 12:20:19.791297',
end_time='2014-06-13 12:50:19.791297',
user_ip=self.ip)
self.answerpaper.questions_answered = '1'
self.attempted_papers = AnswerPaper.objects.filter(question_paper=self.question_paper,
user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer", correct=True, marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer", correct=False, marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.questions
num_questions = len(questions.split('|'))
self.assertEqual(questions, '1|2|3')
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time,
'2014-06-13 12:20:19.791297')
self.assertEqual(self.answerpaper.end_time,
'2014-06-13 12:50:19.791297')
def test_current_question(self):
""" Test current_question() method of Answer Paper"""
current_question = self.answerpaper.current_question()
self.assertEqual(current_question, '2')
def test_completed_question(self):
""" Test completed_question() method of Answer Paper"""
question = self.answerpaper.completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
def test_questions_left(self):
""" Test questions_left() method of Answer Paper"""
self.assertEqual(self.answerpaper.questions_left(), 2)
def test_skip(self):
""" Test skip() method of Answer Paper"""
current_question = self.answerpaper.current_question()
next_question_id = self.answerpaper.skip(current_question)
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id, '3')
def test_answered_str(self):
""" Test answered_str() method of Answer Paper"""
answered_question = self.answerpaper.get_answered_str()
self.assertEqual(answered_question, '1')
def test_update_marks_obtained(self):
""" Test get_marks_obtained() method of Answer Paper"""
self.answerpaper.update_marks_obtained()
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
def test_update_percent(self):
""" Test update_percent() method of Answerpaper"""
self.answerpaper.update_percent()
self.assertEqual(self.answerpaper.percent, 33.33)
def test_update_passed(self):
""" Test update_passed method of AnswerPaper"""
self.answerpaper.update_passed()
self.assertFalse(self.answerpaper.passed)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = answered.values()[0][0]
self.assertEqual(first_answer.answer, 'Demo answer')
self.assertTrue(first_answer.correct)
self.assertEqual(len(answered), 2)
class IntegerQuestionTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
# Creating Course
self.course = Course.objects.get(name="Python Course 100")
# Creating Quiz
self.quiz = Quiz.objects.get(description="demo quiz 100")
# Creating Question paper
self.question_paper = QuestionPaper.objects.get(quiz=self.quiz)
# Creating User
self.user = User.objects.get(username='******')
# Creating Question
self.question1 = Question.objects.create(summary='int1',
points=1,
type='code',
user=self.user)
self.question1.language = 'python'
self.question1.type = "integer"
self.question1.test_case_type = 'integertestcase'
self.question1.description = 'sum of 12+13?'
self.question1.save()
# Creating answerpaper
self.answerpaper = AnswerPaper.objects.create(
user=self.user,
user_ip='101.0.0.1',
start_time=timezone.now(),
question_paper=self.question_paper,
course=self.course,
end_time=timezone.now() + timedelta(minutes=5),
attempt_number=1)
self.answerpaper.questions.add(self.question1)
self.answerpaper.save()
# For question
self.integer_based_testcase = IntegerTestCase(
question=self.question1,
correct=25,
type='integertestcase',
)
self.integer_based_testcase.save()
@classmethod
def tearDownClass(self):
self.question1.delete()
self.answerpaper.delete()
def test_validate_regrade_integer_correct_answer(self):
# Given
integer_answer = 25
self.answer = Answer(
question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
self.answerpaper.save()
# When
json_data = None
result = self.answerpaper.validate_answer(
integer_answer,
self.question1,
json_data,
)
# Then
self.assertTrue(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 200
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 0)
self.assertFalse(self.answer.correct)
def test_validate_regrade_integer_incorrect_answer(self):
# Given
integer_answer = 26
self.answer = Answer(
question=self.question1,
answer=integer_answer,
)
self.answer.save()
self.answerpaper.answers.add(self.answer)
# When
json_data = None
result = self.answerpaper.validate_answer(integer_answer,
self.question1, json_data)
# Then
self.assertFalse(result['success'])
# Regrade
# Given
regrade_answer = Answer.objects.get(id=self.answer.id)
regrade_answer.answer = 25
regrade_answer.save()
# When
details = self.answerpaper.regrade(self.question1.id)
# Then
self.answer = self.answerpaper.answers.filter(
question=self.question1).last()
self.assertEqual(self.answer, regrade_answer)
self.assertTrue(details[0])
self.assertEqual(self.answer.marks, 1)
self.assertTrue(self.answer.correct)
class AnswerPaperTestCases(unittest.TestCase):
@classmethod
def setUpClass(self):
self.ip = '101.0.0.1'
self.user = User.objects.get(id=1)
self.profile = self.user.profile
self.quiz = Quiz.objects.get(pk=1)
self.question_paper = QuestionPaper(quiz=self.quiz, total_marks=3)
self.question_paper.save()
# create answerpaper
self.answerpaper = AnswerPaper(user=self.user,
questions='1|2|3',
question_paper=self.question_paper,
start_time='2014-06-13 12:20:19.791297',
end_time='2014-06-13 12:50:19.791297',
user_ip=self.ip)
self.answerpaper.questions_answered = '1'
self.attempted_papers = AnswerPaper.objects.filter(
question_paper=self.question_paper, user=self.user)
already_attempted = self.attempted_papers.count()
self.answerpaper.attempt_number = already_attempted + 1
self.answerpaper.save()
# answers for the Answer Paper
self.answer_right = Answer(question=Question.objects.get(id=1),
answer="Demo answer",
correct=True,
marks=1)
self.answer_wrong = Answer(question=Question.objects.get(id=2),
answer="My answer",
correct=False,
marks=0)
self.answer_right.save()
self.answer_wrong.save()
self.answerpaper.answers.add(self.answer_right)
self.answerpaper.answers.add(self.answer_wrong)
def test_answerpaper(self):
""" Test Answer Paper"""
self.assertEqual(self.answerpaper.user.username, 'demo_user')
self.assertEqual(self.answerpaper.user_ip, self.ip)
questions = self.answerpaper.questions
num_questions = len(questions.split('|'))
self.assertEqual(questions, '1|2|3')
self.assertEqual(num_questions, 3)
self.assertEqual(self.answerpaper.question_paper, self.question_paper)
self.assertEqual(self.answerpaper.start_time,
'2014-06-13 12:20:19.791297')
self.assertEqual(self.answerpaper.end_time,
'2014-06-13 12:50:19.791297')
def test_current_question(self):
""" Test current_question() method of Answer Paper"""
current_question = self.answerpaper.current_question()
self.assertEqual(current_question, '2')
def test_completed_question(self):
""" Test completed_question() method of Answer Paper"""
question = self.answerpaper.completed_question(1)
self.assertEqual(self.answerpaper.questions_left(), 2)
def test_questions_left(self):
""" Test questions_left() method of Answer Paper"""
self.assertEqual(self.answerpaper.questions_left(), 2)
def test_skip(self):
""" Test skip() method of Answer Paper"""
current_question = self.answerpaper.current_question()
next_question_id = self.answerpaper.skip(current_question)
self.assertTrue(next_question_id is not None)
self.assertEqual(next_question_id, '3')
def test_answered_str(self):
""" Test answered_str() method of Answer Paper"""
answered_question = self.answerpaper.get_answered_str()
self.assertEqual(answered_question, '1')
def test_update_marks_obtained(self):
""" Test get_marks_obtained() method of Answer Paper"""
self.answerpaper.update_marks_obtained()
self.assertEqual(self.answerpaper.marks_obtained, 1.0)
def test_update_percent(self):
""" Test update_percent() method of Answerpaper"""
self.answerpaper.update_percent()
self.assertEqual(self.answerpaper.percent, 33.33)
def test_update_passed(self):
""" Test update_passed method of AnswerPaper"""
self.answerpaper.update_passed()
self.assertFalse(self.answerpaper.passed)
def test_get_question_answer(self):
""" Test get_question_answer() method of Answer Paper"""
answered = self.answerpaper.get_question_answers()
first_answer = answered.values()[0][0]
self.assertEqual(first_answer.answer, 'Demo answer')
self.assertTrue(first_answer.correct)
self.assertEqual(len(answered), 2)
def check(request, q_id, attempt_num=None, questionpaper_id=None):
"""Checks the answers of the user for particular question"""
user = request.user
paper = get_object_or_404(AnswerPaper, user=request.user, attempt_number=attempt_num,
question_paper=questionpaper_id)
question = get_object_or_404(Question, pk=q_id)
if question in paper.questions_answered.all():
next_q = paper.skip(q_id)
return show_question(request, next_q, paper)
if request.method == 'POST':
snippet_code = request.POST.get('snippet')
# Add the answer submitted, regardless of it being correct or not.
if question.type == 'mcq':
user_answer = request.POST.get('answer')
elif question.type == 'mcc':
user_answer = request.POST.getlist('answer')
elif question.type == 'upload':
assign = AssignmentUpload()
assign.user = user.profile
assign.assignmentQuestion = question
# if time-up at upload question then the form is submitted without
# validation
if 'assignment' in request.FILES:
assign.assignmentFile = request.FILES['assignment']
assign.save()
user_answer = 'ASSIGNMENT UPLOADED'
next_q = paper.completed_question(question.id)
return show_question(request, next_q, paper)
else:
user_code = request.POST.get('answer')
user_answer = snippet_code + "\n" + user_code if snippet_code else user_code
new_answer = Answer(question=question, answer=user_answer,
correct=False)
new_answer.save()
paper.answers.add(new_answer)
# If we were not skipped, we were asked to check. For any non-mcq
# questions, we obtain the results via XML-RPC with the code executed
# safely in a separate process (the code_server.py) running as nobody.
test_cases = TestCase.objects.filter(question=question)
json_data = question.consolidate_answer_data(test_cases, user_answer) \
if question.type == 'code' else None
correct, result = validate_answer(user, user_answer, question, json_data)
if correct:
new_answer.correct = correct
new_answer.marks = question.points
new_answer.error = result.get('error')
else:
new_answer.error = result.get('error')
new_answer.save()
paper.update_marks('inprogress')
if not result.get('success'): # Should only happen for non-mcq questions.
new_answer.answer = user_code
new_answer.save()
return show_question(request, question, paper, result.get('error'))
else:
# Display the same question if user_answer is None
if not user_answer:
msg = "Please submit a valid option or code"
return show_question(request, question, paper, msg)
elif question.type == 'code' and user_answer:
msg = "Correct Output"
paper.completed_question(question.id)
return show_question(request, question, paper, msg)
else:
next_q = paper.completed_question(question.id)
return show_question(request, next_q, paper)
else:
return show_question(request, question, paper)
