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)
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
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 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 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):
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 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_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_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 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):
# 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 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)
