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_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)
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 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"
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)