def test_dump_questions(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions_zip = question.dump_questions(question_id, self.user2)
que_file = FileUpload.objects.get(question=self.question2.id)
zip_file = zipfile.ZipFile(questions_zip, "r")
tmp_path = tempfile.mkdtemp()
zip_file.extractall(tmp_path)
test_case = self.question2.get_test_cases()
with open("{0}/questions_dump.json".format(tmp_path), "r") as f:
questions = json.loads(f.read())
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(os.path.basename(que_file.file.path),
q['files'][0][0])
self.assertEqual(
[case.get_field_value() for case in test_case],
q['testcase'])
for file in zip_file.namelist():
os.remove(os.path.join(tmp_path, file))
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()')
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdiobasedtestcase",
user=self.user,
snippet='def myfunc()')
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1, test_case='assert myfunc(12, 13) == 15')
self.stdout_based_testcase = StdioBasedTestCase(
question=self.question2, expected_output='Hello World')
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {
"user_answer":
"demo_answer",
"test_case_data": [{
"test_case": "assert myfunc(12, 13) == 15",
"weight": 0.0
}]
}
self.answer_data_json = json.dumps(answer_data)
def test_assertion_testcase(self):
""" Test question """
self.assertEqual(self.assertion_testcase.question, self.question1)
self.assertEqual(self.assertion_testcase.test_case,
'assert myfunc(12, 13) == 15')
def test_stdout_based_testcase(self):
""" Test question """
self.assertEqual(self.stdout_based_testcase.question, self.question2)
self.assertEqual(self.stdout_based_testcase.expected_output,
'Hello World')
def test_consolidate_answer_data(self):
""" Test consolidate answer data model method """
result = self.question1.consolidate_answer_data(
user_answer="demo_answer")
actual_data = json.loads(result)
exp_data = json.loads(self.answer_data_json)
self.assertEqual(actual_data['user_answer'], exp_data['user_answer'])
self.assertEqual(actual_data['test_case_data'],
exp_data['test_case_data'])
def load_questions_xml(filename):
"""Load questions from the given XML file."""
q_bank = parse(filename).getElementsByTagName("question")
for question in q_bank:
summary_node = question.getElementsByTagName("summary")[0]
summary = (summary_node.childNodes[0].data).strip()
desc_node = question.getElementsByTagName("description")[0]
description = (desc_node.childNodes[0].data).strip()
type_node = question.getElementsByTagName("type")[0]
type = (type_node.childNodes[0].data).strip()
points_node = question.getElementsByTagName("points")[0]
points = float((points_node.childNodes[0].data).strip()) \
if points_node else 1.0
test_node = question.getElementsByTagName("test")[0]
test = decode_html((test_node.childNodes[0].data).strip())
opt_node = question.getElementsByTagName("options")[0]
opt = decode_html((opt_node.childNodes[0].data).strip())
new_question = Question(summary=summary,
description=description,
points=points,
options=opt,
type=type,
test=test)
new_question.save()
def test_dump_questions(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions_zip = question.dump_questions(question_id, self.user2)
que_file = FileUpload.objects.get(question=self.question2.id)
zip_file = zipfile.ZipFile(questions_zip, "r")
tmp_path = tempfile.mkdtemp()
zip_file.extractall(tmp_path)
test_case = self.question2.get_test_cases()
with open("{0}/questions_dump.json".format(tmp_path), "r") as f:
questions = json.loads(f.read())
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(self.question2.test_case_type, q['test_case_type'])
self.assertEqual(os.path.basename(que_file.file.path), q['files'][0][0])
self.assertEqual([case.get_field_value() for case in test_case], q['testcase'])
for file in zip_file.namelist():
os.remove(os.path.join(tmp_path, file))
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()')
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdiobasedtestcase",
user=self.user,
snippet='def myfunc()')
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1, test_case='assert myfunc(12, 13) == 15')
self.stdout_based_testcase = StdioBasedTestCase(
question=self.question2, expected_output='Hello World')
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {
"user_answer": "demo_answer",
"test_case_data": [{
"test_case": "assert myfunc(12, 13) == 15"
}]
}
self.answer_data_json = json.dumps(answer_data)
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.question = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()')
self.question.save()
self.question.tags.add('python', 'function')
self.testcase = TestCase(question=self.question,
func_name='def myfunc',
kw_args='a=10,b=11',
pos_args='12,13',
expected_answer='15')
answer_data = {
"test":
"",
"user_answer":
"demo_answer",
"test_parameter": [{
"func_name": "def myfunc",
"expected_answer": "15",
"test_id": self.testcase.id,
"pos_args": ["12", "13"],
"kw_args": {
"a": "10",
"b": "11"
}
}],
"id":
self.question.id,
"ref_code_path":
"",
}
self.answer_data_json = json.dumps(answer_data)
self.user_answer = "demo_answer"
def test_question(self):
""" Test question """
self.assertEqual(self.question.summary, 'Demo question')
self.assertEqual(self.question.language, 'Python')
self.assertEqual(self.question.type, 'Code')
self.assertFalse(self.question.options)
self.assertEqual(self.question.description, 'Write a function')
self.assertEqual(self.question.points, 1.0)
self.assertTrue(self.question.active)
self.assertEqual(self.question.snippet, 'def myfunc()')
tag_list = []
for tag in self.question.tags.all():
tag_list.append(tag.name)
self.assertEqual(tag_list, ['python', 'function'])
def test_consolidate_answer_data(self):
""" Test consolidate_answer_data function """
result = self.question.consolidate_answer_data([self.testcase],
self.user_answer)
self.assertEqual(result, self.answer_data_json)
def test_load_questions_from_json(self):
""" Test load questions into database from json """
question = Question()
result = question.load_from_json(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
def test_dump_questions_into_json(self):
""" Test dump questions into json """
question = Question()
question_id = ['24']
questions = json.loads(question.dump_into_json(question_id, self.user1))
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
def setUp(self):
self.question = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()')
self.question.save()
self.testcase = TestCase(question=self.question,
func_name='def myfunc',
kw_args='a=10,b=11',
pos_args='12,13',
expected_answer='15')
def show_all_questions(request):
"""Show a list of all the questions currently in the databse."""
user = request.user
ci = RequestContext(request)
context = {}
if not is_moderator(user):
raise Http404("You are not allowed to view this page !")
if request.method == 'POST':
if request.POST.get('delete') == 'delete':
data = request.POST.getlist('question')
if data is not None:
question = Question.objects.filter(id__in=data, user_id=user.id).delete()
if request.POST.get('upload') == 'upload':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
questions_file = request.FILES['file']
if questions_file.name.split('.')[-1] == "json":
questions_list = questions_file.read()
question = Question()
question.load_from_json(questions_list, user)
else:
message = "Please Upload a JSON file"
context['message'] = message
if request.POST.get('download') == 'download':
question_ids = request.POST.getlist('question')
if question_ids:
question = Question()
questions = question.dump_into_json(question_ids, user)
response = HttpResponse(questions, content_type='text/json')
response['Content-Disposition'] = 'attachment; filename=\
"{0}_questions.json"'.format(user)
return response
else:
msg = "Please select atleast one question"
context['msg'] = msg
questions = Question.objects.filter(user_id=user.id)
form = QuestionFilterForm(user=user)
upload_form = UploadFileForm()
context['papers'] = []
context['question'] = None
context['questions'] = questions
context['form'] = form
context['upload_form'] = upload_form
return my_render_to_response('yaksh/showquestions.html', context,
context_instance=ci)
def test_load_questions_from_json(self):
""" Test load questions into database from json """
question = Question()
result = question.load_from_json(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(question_data.test_case_type, 'standardtestcase')
self.assertEqual([case.get_field_value() for case in test_case], self.test_case_upload_data)
def setUp(self):
# Single question details
self.question = Question(summary='Demo question', language='Python',
type='Code', active=True,
description='Write a function', points=1.0,
snippet='def myfunc()')
self.question.save()
self.question.tags.add('python', 'function')
self.testcase = TestCase(question=self.question,
func_name='def myfunc', kw_args='a=10,b=11',
pos_args='12,13', expected_answer='15')
answer_data = { "test": "",
"user_answer": "demo_answer",
"test_parameter": [{"func_name": "def myfunc",
"expected_answer": "15",
"test_id": self.testcase.id,
"pos_args": ["12", "13"],
"kw_args": {"a": "10",
"b": "11"}
}],
"id": self.question.id,
"ref_code_path": "",
}
self.answer_data_json = json.dumps(answer_data)
self.user_answer = "demo_answer"
def test_load_questions_from_json(self):
""" Test load questions into database from json """
question = Question()
result = question.load_from_json(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(question_data.test_case_type, 'standardtestcase')
self.assertEqual([case.get_field_value() for case in test_case],
self.test_case_upload_data)
def test_dump_questions_into_json(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions = json.loads(question.dump_into_json(question_id, self.user2))
test_case = self.question2.get_test_cases()
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(self.question2.test_case_type, q['test_case_type'])
self.assertEqual([case.get_field_value() for case in test_case], q['testcase'])
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdiobasedtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase'
)
self.stdout_based_testcase = StdIOBasedTestCase(
question=self.question2,
expected_output='Hello World',
type='standardtestcase'
)
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {'metadata': { 'user_answer': 'demo_answer',
'language': 'python',
'partial_grading': False
},
'test_case_data': [{'test_case': 'assert myfunc(12, 13) == 15',
'test_case_type': 'standardtestcase',
'weight': 1.0
}]
}
self.answer_data_json = json.dumps(answer_data)
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.question = Question(summary='Demo question', language='Python',
type='Code', active=True,
description='Write a function', points=1.0,
snippet='def myfunc()')
self.question.save()
self.question.tags.add('python', 'function')
self.testcase = TestCase(question=self.question,
func_name='def myfunc', kw_args='a=10,b=11',
pos_args='12,13', expected_answer='15')
answer_data = { "test": "",
"user_answer": "demo_answer",
"test_parameter": [{"func_name": "def myfunc",
"expected_answer": "15",
"test_id": self.testcase.id,
"pos_args": ["12", "13"],
"kw_args": {"a": "10",
"b": "11"}
}],
"id": self.question.id,
"ref_code_path": "",
}
self.answer_data_json = json.dumps(answer_data)
self.user_answer = "demo_answer"
def test_question(self):
""" Test question """
self.assertEqual(self.question.summary, 'Demo question')
self.assertEqual(self.question.language, 'Python')
self.assertEqual(self.question.type, 'Code')
self.assertFalse(self.question.options)
self.assertEqual(self.question.description, 'Write a function')
self.assertEqual(self.question.points, 1.0)
self.assertTrue(self.question.active)
self.assertEqual(self.question.snippet, 'def myfunc()')
tag_list = []
for tag in self.question.tags.all():
tag_list.append(tag.name)
self.assertEqual(tag_list, ['python', 'function'])
def test_consolidate_answer_data(self):
""" Test consolidate_answer_data function """
result = self.question.consolidate_answer_data([self.testcase],
self.user_answer)
self.assertEqual(result, self.answer_data_json)
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
test_case_type='standardtestcase',
points=2.0,
snippet='def fact()',
user=self.user2)
self.question2.save()
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(
question=self.question1, test_case='assert myfunc(12, 13) == 15')
self.upload_test_case = StandardTestCase(
question=self.question2, test_case='assert fact(3) == 6')
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{"test_case": "assert fact(3)==6"}]
questions_data = [{
"snippet": "def fact()",
"active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python",
"type": "Code",
"test_case_type": "standardtestcase",
"testcase": self.test_case_upload_data,
"summary": "Json Demo"
}]
self.json_questions_data = json.dumps(questions_data)
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1
)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
test_case_type='standardtestcase',
points=2.0,
snippet='def fact()',
user=self.user2
)
self.question2.save()
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(question=self.question1,
test_case='assert myfunc(12, 13) == 15'
)
self.upload_test_case = StandardTestCase(question=self.question2,
test_case='assert fact(3) == 6'
)
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{"test_case": "assert fact(3)==6"}]
questions_data = [{"snippet": "def fact()", "active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python", "type": "Code",
"test_case_type": "standardtestcase",
"testcase": self.test_case_upload_data,
"summary": "Json Demo"}]
self.json_questions_data = json.dumps(questions_data)
def test_load_questions(self):
""" Test load questions into database from json """
question = Question()
result = question.load_questions(self.json_questions_data, self.user1)
question_data = Question.objects.get(summary="Json Demo")
file = FileUpload.objects.get(question=question_data)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(os.path.basename(file.file.path), "test.txt")
self.assertEqual([case.get_field_value() for case in test_case],
self.test_case_upload_data)
def setUp(self):
self.question = Question(summary='Demo question', language='Python',
type='Code', active=True,
description='Write a function', points=1.0,
snippet='def myfunc()')
self.question.save()
self.testcase = TestCase(question=self.question,
func_name='def myfunc', kw_args='a=10,b=11',
pos_args='12,13', expected_answer='15')
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.question = Question(summary='Demo question', language='Python',
type='Code', active=True,
description='Write a function', points=1.0,
snippet='def myfunc()')
self.question.save()
self.testcase = TestCase(question=self.question,
func_name='def myfunc', kw_args='a=10,b=11',
pos_args='12,13', expected_answer='15')
def test_testcase(self):
""" Test question """
self.assertEqual(self.testcase.question, self.question)
self.assertEqual(self.testcase.func_name, 'def myfunc')
self.assertEqual(self.testcase.kw_args, 'a=10,b=11')
self.assertEqual(self.testcase.pos_args, '12,13')
self.assertEqual(self.testcase.expected_answer, '15')
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
user=self.user,
snippet='def myfunc()')
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
user=self.user,
snippet='def myfunc()')
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase')
self.stdout_based_testcase = StdIOBasedTestCase(
question=self.question2,
expected_output='Hello World',
type='standardtestcase')
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {
'metadata': {
'user_answer': 'demo_answer',
'language': 'python',
'partial_grading': False
},
'test_case_data': [{
'test_case': 'assert myfunc(12, 13) == 15',
'test_case_type': 'standardtestcase',
'test_case_args': "",
'weight': 1.0
}]
}
self.answer_data_json = json.dumps(answer_data)
def test_dump_questions_into_json(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions = json.loads(question.dump_into_json(question_id,
self.user2))
test_case = self.question2.get_test_cases()
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(self.question2.test_case_type,
q['test_case_type'])
self.assertEqual([case.get_field_value() for case in test_case],
q['testcase'])
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdoutbasedtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15'
)
self.stdout_based_testcase = StdoutBasedTestCase(
question=self.question2,
expected_output='Hello World'
)
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {"user_answer": "demo_answer",
"test_case_data": [
{"test_case": "assert myfunc(12, 13) == 15"}
]
}
self.answer_data_json = json.dumps(answer_data)
def setUp(self):
# Single question details
self.question = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()')
self.question.save()
self.question.tags.add('python', 'function')
self.testcase = TestCase(question=self.question,
func_name='def myfunc',
kw_args='a=10,b=11',
pos_args='12,13',
expected_answer='15')
answer_data = {
"test":
"",
"user_answer":
"demo_answer",
"test_parameter": [{
"func_name": "def myfunc",
"expected_answer": "15",
"test_id": self.testcase.id,
"pos_args": ["12", "13"],
"kw_args": {
"a": "10",
"b": "11"
}
}],
"id":
self.question.id,
"ref_code_path":
"",
}
self.answer_data_json = json.dumps(answer_data)
self.user_answer = "demo_answer"
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.question = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()')
self.question.save()
self.testcase = TestCase(question=self.question,
func_name='def myfunc',
kw_args='a=10,b=11',
pos_args='12,13',
expected_answer='15')
def test_testcase(self):
""" Test question """
self.assertEqual(self.testcase.question, self.question)
self.assertEqual(self.testcase.func_name, 'def myfunc')
self.assertEqual(self.testcase.kw_args, 'a=10,b=11')
self.assertEqual(self.testcase.pos_args, '12,13')
self.assertEqual(self.testcase.expected_answer, '15')
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1
)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
test_case_type='standardtestcase',
points=2.0,
snippet='def fact()',
user=self.user2
)
self.question2.save()
# create a temp directory and add files for loading questions test
file_path = "/tmp/test.txt"
self.load_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.load_tmp_path)
file1 = os.path.join(self.load_tmp_path, "test.txt")
# create a temp directory and add files for dumping questions test
self.dump_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.dump_tmp_path)
file2 = os.path.join(self.dump_tmp_path, "test.txt")
file = open(file2, "r")
django_file = File(file)
file = FileUpload.objects.create(file=django_file, question=self.question2)
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase'
)
self.upload_test_case = StandardTestCase(question=self.question2,
test_case='assert fact(3) == 6',
type='standardtestcase'
)
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{"test_case": "assert fact(3)==6",
"test_case_type": "standardtestcase",
"weight": 1.0
}]
questions_data = [{"snippet": "def fact()", "active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python", "type": "Code",
"testcase": self.test_case_upload_data,
"files": [[file1, 0]],
"summary": "Json Demo"}]
self.json_questions_data = json.dumps(questions_data)
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1
)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
test_case_type='standardtestcase',
points=2.0,
snippet='def fact()',
user=self.user2
)
self.question2.save()
# create a temp directory and add files for loading questions test
file_path = "/tmp/test.txt"
self.load_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.load_tmp_path)
file1 = os.path.join(self.load_tmp_path, "test.txt")
# create a temp directory and add files for dumping questions test
self.dump_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.dump_tmp_path)
file2 = os.path.join(self.dump_tmp_path, "test.txt")
file = open(file2, "r")
django_file = File(file)
file = FileUpload.objects.create(file=django_file, question=self.question2)
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase'
)
self.upload_test_case = StandardTestCase(question=self.question2,
test_case='assert fact(3) == 6',
type='standardtestcase'
)
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{"test_case": "assert fact(3)==6",
"test_case_type": "standardtestcase",
"weight": 1.0
}]
questions_data = [{"snippet": "def fact()", "active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python", "type": "Code",
"testcase": self.test_case_upload_data,
"files": [[file1, 0]],
"summary": "Json Demo"}]
self.json_questions_data = json.dumps(questions_data)
def tearDown(self):
shutil.rmtree(self.load_tmp_path)
shutil.rmtree(self.dump_tmp_path)
def test_question(self):
""" Test question """
self.assertEqual(self.question1.summary, 'Demo question')
self.assertEqual(self.question1.language, 'Python')
self.assertEqual(self.question1.type, 'Code')
self.assertEqual(self.question1.description, 'Write a function')
self.assertEqual(self.question1.points, 1.0)
self.assertTrue(self.question1.active)
self.assertEqual(self.question1.snippet, 'def myfunc()')
tag_list = []
for tag in self.question1.tags.all():
tag_list.append(tag.name)
for tag in tag_list:
self.assertIn(tag, ['python', 'function'])
def test_dump_questions(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions_zip = question.dump_questions(question_id, self.user2)
que_file = FileUpload.objects.get(question=self.question2.id)
zip_file = zipfile.ZipFile(questions_zip, "r")
tmp_path = tempfile.mkdtemp()
zip_file.extractall(tmp_path)
test_case = self.question2.get_test_cases()
with open("{0}/questions_dump.json".format(tmp_path), "r") as f:
questions = json.loads(f.read())
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(self.question2.test_case_type, q['test_case_type'])
self.assertEqual(os.path.basename(que_file.file.path), q['files'][0][0])
self.assertEqual([case.get_field_value() for case in test_case], q['testcase'])
for file in zip_file.namelist():
os.remove(os.path.join(tmp_path, file))
def test_load_questions(self):
""" Test load questions into database from json """
question = Question()
result = question.load_questions(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
file = FileUpload.objects.get(question=25)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(os.path.basename(file.file.path), "test.txt")
self.assertEqual([case.get_field_value() for case in test_case], self.test_case_upload_data)
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdiobasedtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase'
)
self.stdout_based_testcase = StdIOBasedTestCase(
question=self.question2,
expected_output='Hello World',
type='standardtestcase'
)
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {'metadata': { 'user_answer': 'demo_answer',
'language': 'python',
'partial_grading': False
},
'test_case_data': [{'test_case': 'assert myfunc(12, 13) == 15',
'test_case_type': 'standardtestcase',
'weight': 1.0
}]
}
self.answer_data_json = json.dumps(answer_data)
def test_assertion_testcase(self):
""" Test question """
self.assertEqual(self.assertion_testcase.question, self.question1)
self.assertEqual(self.assertion_testcase.test_case,
'assert myfunc(12, 13) == 15')
def test_stdout_based_testcase(self):
""" Test question """
self.assertEqual(self.stdout_based_testcase.question, self.question2)
self.assertEqual(self.stdout_based_testcase.expected_output,
'Hello World'
)
def test_consolidate_answer_data(self):
""" Test consolidate answer data model method """
result = self.question1.consolidate_answer_data(
user_answer="demo_answer"
)
actual_data = json.loads(result)
exp_data = json.loads(self.answer_data_json)
self.assertEqual(actual_data['metadata']['user_answer'], exp_data['metadata']['user_answer'])
self.assertEqual(actual_data['test_case_data'], exp_data['test_case_data'])
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.user = User.objects.get(username="******")
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
user=self.user,
snippet='def myfunc()')
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
user=self.user,
snippet='def myfunc()')
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase')
self.stdout_based_testcase = StdIOBasedTestCase(
question=self.question2,
expected_output='Hello World',
type='standardtestcase')
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {
'metadata': {
'user_answer': 'demo_answer',
'language': 'python',
'partial_grading': False
},
'test_case_data': [{
'test_case': 'assert myfunc(12, 13) == 15',
'test_case_type': 'standardtestcase',
'test_case_args': "",
'weight': 1.0
}]
}
self.answer_data_json = json.dumps(answer_data)
def test_assertion_testcase(self):
""" Test question """
self.assertEqual(self.assertion_testcase.question, self.question1)
self.assertEqual(self.assertion_testcase.test_case,
'assert myfunc(12, 13) == 15')
def test_stdout_based_testcase(self):
""" Test question """
self.assertEqual(self.stdout_based_testcase.question, self.question2)
self.assertEqual(self.stdout_based_testcase.expected_output,
'Hello World')
def test_consolidate_answer_data(self):
""" Test consolidate answer data model method """
result = self.question1.consolidate_answer_data(
user_answer="demo_answer")
actual_data = json.loads(result)
exp_data = json.loads(self.answer_data_json)
self.assertEqual(actual_data['metadata']['user_answer'],
exp_data['metadata']['user_answer'])
self.assertEqual(actual_data['test_case_data'],
exp_data['test_case_data'])
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1
)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
points=2.0,
snippet='def fact()',
user=self.user2
)
self.question2.save()
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(question=self.question1,
test_case='assert myfunc(12, 13) == 15'
)
self.user_answer = "demo_answer"
questions_data = [{"snippet": "def fact()", "active": True, "points": 1.0,
"description": "factorial of a no",
"language": "Python", "type": "Code",
"summary": "Json Demo"}]
self.json_questions_data = json.dumps(questions_data)
def test_question(self):
""" Test question """
self.assertEqual(self.question1.summary, 'Demo question')
self.assertEqual(self.question1.language, 'Python')
self.assertEqual(self.question1.type, 'Code')
self.assertEqual(self.question1.description, 'Write a function')
self.assertEqual(self.question1.points, 1.0)
self.assertTrue(self.question1.active)
self.assertEqual(self.question1.snippet, 'def myfunc()')
tag_list = []
for tag in self.question1.tags.all():
tag_list.append(tag.name)
self.assertEqual(tag_list, ['python', 'function'])
def test_dump_questions_into_json(self):
""" Test dump questions into json """
question = Question()
question_id = ['24']
questions = json.loads(question.dump_into_json(question_id, self.user1))
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
def test_load_questions_from_json(self):
""" Test load questions into database from json """
question = Question()
result = question.load_from_json(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
class TestCaseTestCases(unittest.TestCase):
def setUp(self):
self.user = User.objects.get(pk=1)
self.question1 = Question(summary='Demo question 1',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
test_case_type="standardtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question2 = Question(summary='Demo question 2',
language='Python',
type='Code',
active=True,
description='Write to standard output',
points=1.0,
test_case_type="stdoutbasedtestcase",
user=self.user,
snippet='def myfunc()'
)
self.question1.save()
self.question2.save()
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15'
)
self.stdout_based_testcase = StdoutBasedTestCase(
question=self.question2,
expected_output='Hello World'
)
self.assertion_testcase.save()
self.stdout_based_testcase.save()
answer_data = {"user_answer": "demo_answer",
"test_case_data": [
{"test_case": "assert myfunc(12, 13) == 15"}
]
}
self.answer_data_json = json.dumps(answer_data)
def test_assertion_testcase(self):
""" Test question """
self.assertEqual(self.assertion_testcase.question, self.question1)
self.assertEqual(self.assertion_testcase.test_case,
'assert myfunc(12, 13) == 15')
def test_stdout_based_testcase(self):
""" Test question """
self.assertEqual(self.stdout_based_testcase.question, self.question2)
self.assertEqual(self.stdout_based_testcase.expected_output,
'Hello World'
)
def test_consolidate_answer_data(self):
""" Test consolidate answer data model method """
result = self.question1.consolidate_answer_data(
user_answer="demo_answer"
)
self.assertEqual(result, self.answer_data_json)
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
points=2.0,
snippet='def fact()',
user=self.user2)
self.question2.save()
# create a temp directory and add files for loading questions test
file_path = "/tmp/test.txt"
self.load_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.load_tmp_path)
file1 = os.path.join(self.load_tmp_path, "test.txt")
# create a temp directory and add files for dumping questions test
self.dump_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.dump_tmp_path)
file2 = os.path.join(self.dump_tmp_path, "test.txt")
file = open(file2, "r")
django_file = File(file)
file = FileUpload.objects.create(file=django_file,
question=self.question2)
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase')
self.upload_test_case = StandardTestCase(
question=self.question2,
test_case='assert fact(3) == 6',
type='standardtestcase')
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{
"test_case": "assert fact(3)==6",
"test_case_type": "standardtestcase",
"test_case_args": "",
"weight": 1.0
}]
questions_data = [{
"snippet": "def fact()",
"active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python",
"type": "Code",
"testcase": self.test_case_upload_data,
"files": [[file1, 0]],
"summary": "Json Demo"
}]
self.json_questions_data = json.dumps(questions_data)
def tearDown(self):
shutil.rmtree(self.load_tmp_path)
shutil.rmtree(self.dump_tmp_path)
def test_question(self):
""" Test question """
self.assertEqual(self.question1.summary, 'Demo question')
self.assertEqual(self.question1.language, 'Python')
self.assertEqual(self.question1.type, 'Code')
self.assertEqual(self.question1.description, 'Write a function')
self.assertEqual(self.question1.points, 1.0)
self.assertTrue(self.question1.active)
self.assertEqual(self.question1.snippet, 'def myfunc()')
tag_list = []
for tag in self.question1.tags.all():
tag_list.append(tag.name)
for tag in tag_list:
self.assertIn(tag, ['python', 'function'])
def test_dump_questions(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions_zip = question.dump_questions(question_id, self.user2)
que_file = FileUpload.objects.get(question=self.question2.id)
zip_file = zipfile.ZipFile(questions_zip, "r")
tmp_path = tempfile.mkdtemp()
zip_file.extractall(tmp_path)
test_case = self.question2.get_test_cases()
with open("{0}/questions_dump.json".format(tmp_path), "r") as f:
questions = json.loads(f.read())
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(os.path.basename(que_file.file.path),
q['files'][0][0])
self.assertEqual(
[case.get_field_value() for case in test_case],
q['testcase'])
for file in zip_file.namelist():
os.remove(os.path.join(tmp_path, file))
def test_load_questions(self):
""" Test load questions into database from json """
question = Question()
result = question.load_questions(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
file = FileUpload.objects.get(question=25)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(os.path.basename(file.file.path), "test.txt")
self.assertEqual([case.get_field_value() for case in test_case],
self.test_case_upload_data)
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
points=2.0,
snippet='def fact()',
user=self.user2)
self.question2.save()
# create a temp directory and add files for loading questions test
file_path = "/tmp/test.txt"
self.load_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.load_tmp_path)
file1 = os.path.join(self.load_tmp_path, "test.txt")
# create a temp directory and add files for dumping questions test
self.dump_tmp_path = tempfile.mkdtemp()
shutil.copy(file_path, self.dump_tmp_path)
file2 = os.path.join(self.dump_tmp_path, "test.txt")
file = open(file2, "r")
django_file = File(file)
file = FileUpload.objects.create(file=django_file,
question=self.question2)
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(
question=self.question1,
test_case='assert myfunc(12, 13) == 15',
type='standardtestcase')
self.upload_test_case = StandardTestCase(
question=self.question2,
test_case='assert fact(3) == 6',
type='standardtestcase')
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{
"test_case": "assert fact(3)==6",
"test_case_type": "standardtestcase",
"test_case_args": "",
"weight": 1.0
}]
questions_data = [{
"snippet": "def fact()",
"active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python",
"type": "Code",
"testcase": self.test_case_upload_data,
"files": [[file1, 0]],
"summary": "Json Demo"
}]
self.json_questions_data = json.dumps(questions_data)
def save(self, commit=True):
summary = self.cleaned_data.get("summary")
description = self.cleaned_data.get("description")
points = self.cleaned_data.get("points")
test = self.cleaned_data.get("test")
options = self.cleaned_data.get("options")
language = self.cleaned_data.get("language")
type = self.cleaned_data.get("type")
active = self.cleaned_data.get("active")
snippet = self.cleaned_data.get("snippet")
new_question = Question()
new_question.summary = summary
new_question.description = description
new_question.points = points
new_question.test = test
new_question.options = options
new_question.language = language
new_question.type = type
new_question.active = active
new_question.snippet = snippet
new_question = super(QuestionForm, self).save(commit=False)
if commit:
new_question.save()
return new_question
class QuestionTestCases(unittest.TestCase):
def setUp(self):
# Single question details
self.user1 = User.objects.get(pk=1)
self.user2 = User.objects.get(pk=2)
self.question1 = Question(summary='Demo question',
language='Python',
type='Code',
active=True,
test_case_type='standardtestcase',
description='Write a function',
points=1.0,
snippet='def myfunc()',
user=self.user1)
self.question1.save()
self.question2 = Question(summary='Demo Json',
language='python',
type='code',
active=True,
description='factorial of a no',
test_case_type='standardtestcase',
points=2.0,
snippet='def fact()',
user=self.user2)
self.question2.save()
self.question1.tags.add('python', 'function')
self.assertion_testcase = StandardTestCase(
question=self.question1, test_case='assert myfunc(12, 13) == 15')
self.upload_test_case = StandardTestCase(
question=self.question2, test_case='assert fact(3) == 6')
self.upload_test_case.save()
self.user_answer = "demo_answer"
self.test_case_upload_data = [{"test_case": "assert fact(3)==6"}]
questions_data = [{
"snippet": "def fact()",
"active": True,
"points": 1.0,
"description": "factorial of a no",
"language": "Python",
"type": "Code",
"test_case_type": "standardtestcase",
"testcase": self.test_case_upload_data,
"summary": "Json Demo"
}]
self.json_questions_data = json.dumps(questions_data)
def test_question(self):
""" Test question """
self.assertEqual(self.question1.summary, 'Demo question')
self.assertEqual(self.question1.language, 'Python')
self.assertEqual(self.question1.type, 'Code')
self.assertEqual(self.question1.description, 'Write a function')
self.assertEqual(self.question1.points, 1.0)
self.assertTrue(self.question1.active)
self.assertEqual(self.question1.snippet, 'def myfunc()')
tag_list = []
for tag in self.question1.tags.all():
tag_list.append(tag.name)
self.assertEqual(tag_list, ['python', 'function'])
def test_dump_questions_into_json(self):
""" Test dump questions into json """
question = Question()
question_id = [self.question2.id]
questions = json.loads(question.dump_into_json(question_id,
self.user2))
test_case = self.question2.get_test_cases()
for q in questions:
self.assertEqual(self.question2.summary, q['summary'])
self.assertEqual(self.question2.language, q['language'])
self.assertEqual(self.question2.type, q['type'])
self.assertEqual(self.question2.description, q['description'])
self.assertEqual(self.question2.points, q['points'])
self.assertTrue(self.question2.active)
self.assertEqual(self.question2.snippet, q['snippet'])
self.assertEqual(self.question2.test_case_type,
q['test_case_type'])
self.assertEqual([case.get_field_value() for case in test_case],
q['testcase'])
def test_load_questions_from_json(self):
""" Test load questions into database from json """
question = Question()
result = question.load_from_json(self.json_questions_data, self.user1)
question_data = Question.objects.get(pk=25)
test_case = question_data.get_test_cases()
self.assertEqual(question_data.summary, 'Json Demo')
self.assertEqual(question_data.language, 'Python')
self.assertEqual(question_data.type, 'Code')
self.assertEqual(question_data.description, 'factorial of a no')
self.assertEqual(question_data.points, 1.0)
self.assertTrue(question_data.active)
self.assertEqual(question_data.snippet, 'def fact()')
self.assertEqual(question_data.test_case_type, 'standardtestcase')
self.assertEqual([case.get_field_value() for case in test_case],
self.test_case_upload_data)
