# import glob # import json # import os # from datetime import timedelta # from re import T # import tempfile # # from PIL import Image # # from django.utils import timezone # # from authenticate.models import User # from exam.models import EXAM_PAGE_STATE_FINISHED, EXAM_PAGE_STATE_SCORES_PUBLISHED, Corrections, ExamTemplate, Exam, ExamPage, PublicExamTemplate, ALLOWED_ENTRANCE_TYPES, ENTRANCE_TYPE_PUBLIC, \ # ENTRANCE_TYPE_API_INVITE # from exam.validators import QUERY_QUESTION_LIST_BY_FILTERING # from institute.models import InstituteStudent, Institute # from payment.models import UserBalanceHistory, InstituteBalanceHistory, WikiazmaBalanceHistory, ExamPurchase # from plan.models import Environment # from wikiazma.myTest import MyTestCase # # # class ExamTest(MyTestCase): # # def setUp(self): # self.setUpHelpers() # self.setBaseUser() # # Environment.objects.update( # default_max_institutes_per_user=100, default_max_collaborators_per_institute=100) # self.institute = self.instituteHelper.create_institute( # name="unit_test_institute") # # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=60000) # # def tearDown(self): # files = glob.glob('test_files/*') # for file in files: # if not file.endswith(('/image.png', '\image.png', 'fakepng.png', '.pdf')): # os.remove(file) # Corrections.objects.all().delete() # InstituteStudent.objects.all().delete() # ExamPage.objects.all().delete() # Exam.objects.all().delete() # ExamTemplate.objects.all().delete() # PublicExamTemplate.objects.all().delete() # Institute.objects.all().delete() # User.objects.all().delete() # # def test_create_exam_success(self): # # default one group # self.examHelper.create_exam_helper(self.institute['id']) # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # one group with null name # rules = {'groups': [ # { # "id": 12345678, # "name": 'group1', # "questions": [self.examHelper.referenced_question_retrievers[0]] # } # ]} # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=1) # # # one group with a non-null name # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=1) # # # two groups # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "physics1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=2) # # # default one group with create_exam_template # self.examHelper.create_exam_helper( # self.institute['id'], create_exam_template=True) # # # testing two public access_types in query_question_by_id # # question_bank is also in our institute # self.examHelper.generate_referenced_question_retrievers( # self.institute['id'], public=True, force_clear=True) # rules = {'groups': [ # { # "id": 12345678, # "name": 'math1', # # "questions": [ # self.examHelper.referenced_question_retrievers[0], # self.examHelper.referenced_question_retrievers[1] # ] # } # ]} # # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=2) # # # testing two public access_types in query_question_by_id # # question_bank is not in our institute # (user2, token2) = self.authenticateHelper.new_user_with_email() # institute2 = self.instituteHelper.create_institute( # name="unit_test_institute2", token=token2) # # self.examHelper.generate_referenced_question_retrievers(institute2['id'], public=True, force_clear=True, # token=token2) # rules = {'groups': [ # { # "id": 12345678, # "name": 'math1', # "questions": [ # self.examHelper.referenced_question_retrievers[0], # self.examHelper.referenced_question_retrievers[1], # self.examHelper.referenced_question_retrievers[2], # ] # } # ]} # # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=3) # # # testing three public access_types and two owned access_types in query_question_by_id # (user2, token2) = self.authenticateHelper.new_user_with_email() # institute2 = self.instituteHelper.create_institute( # name="unit_test_institute2", token=token2) # self.examHelper.generate_referenced_question_retrievers(institute2['id'], public=True, force_clear=True, # token=token2) # # # three public questions # questions = [ # self.examHelper.referenced_question_retrievers[0], # self.examHelper.referenced_question_retrievers[1], # self.examHelper.referenced_question_retrievers[2], # ] # # self.examHelper.generate_referenced_question_retrievers( # self.institute['id'], public=False, force_clear=True) # # two owned questions # questions.append(self.examHelper.referenced_question_retrievers[0]) # questions.append(self.examHelper.referenced_question_retrievers[1]) # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": questions # }, # ]} # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=5) # # # delayed=False # self.examHelper.create_exam_helper( # self.institute['id'], delayable=False) # # # delayed=True # self.examHelper.create_exam_helper( # self.institute['id'], delayable=True, max_delay="00:30:00") # # def test_create_exam_with_query_question_list_by_filtering_success(self): # question_bank_id = self.questionbankHelper.create_question_bank( # self.institute['id']) # # # one group with null name # rules = {'groups': [ # { # "id": 12345678, # "name": 'group1', # "questions": [ # { # "type": QUERY_QUESTION_LIST_BY_FILTERING, # "priority": 1, # "count": 5, # "positive_score_per_question": 2.5, # "negative_score_per_question": 1.0, # "duration_per_question": 20.0, # "question_bank_id": question_bank_id, # "tag_filters": [], # 'type_filter': None # } # ] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # # question_bank_id = self.questionbankHelper.create_question_bank( # self.institute['id']) # # # one group with null name # # rules = {'groups': [ # { # "id": 12345678, # "name": MyTestCase.str1000, # "questions": [ # { # "type": QUERY_QUESTION_LIST_BY_FILTERING, # "priority": 1, # "count": 5, # "positive_score_per_question": 2.5, # "negative_score_per_question": 1.0, # "duration_per_question": 20.0, # "question_bank_id": question_bank_id, # "tag_filters": [], # 'type_filter': None # } # ] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertEqual('In each group, name should be at most 1000 characters', # response_data['fields']['rules'], error_message) # # def test_create_exam_with_some_groups_and_with_null_or_empty_group_name(self): # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # rules = {'groups': [ # { # "id": 12345678, # "name": None, # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "physics1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual("valid 'name' was not found in one of the items in groups. Each item in groups must only contain id(int)*, name(str)*, questions(list)*.", # response_data['fields']['rules'], error_message) # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('In each group, name should be at most 1000 characters', # response_data['fields']['rules'], error_message) # # rules = {'groups': [ # { # "id": 12345678, # "name": "", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": None, # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('In each group, name should be at most 1000 characters', # response_data['fields']['rules'], error_message) # # def test_create_exam_invalid_question_type_error(self): # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # creating an invalid type in questions list # self.examHelper.referenced_question_retrievers[0]['type'] = "invalid_type" # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('in each question, type should be one of QueryQuestionById, QueryQuestionListByFiltering', # response_data['fields']['rules'], error_message) # # def test_create_exam_error(self): # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # # creating an invalid id in questions list # self.examHelper.referenced_question_retrievers[1]['question_id'] = "invalid_id" # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "physics1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('"invalid_id" is not a valid UUID.', # response_data['fields']['rules'], error_message) # # # using a non-existing uuid # self.examHelper.referenced_question_retrievers[1]['question_id'] = "123e4567-e89b-12d3-a456-426614174000" # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "physics1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual( # 'Question "123e4567-e89b-12d3-a456-426614174000" not found', response_data['message'], error_message) # # self.examHelper.generate_referenced_question_retrievers( # self.institute['id'], force_clear=True) # # # self.examHelper.query_question_by_id_object[1]['access_type'] = "public" # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "physics1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, validate_success=False) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # # (user2, token2) = self.authenticateHelper.new_user_with_email() # institute2 = self.instituteHelper.create_institute( # name="unit_test_institute2", token=token2) # # self.examHelper.generate_referenced_question_retrievers(institute2['id'], force_clear=True, # token=token2) # rules = {'groups': [ # { # "id": 12345678, # "name": 'math1', # "questions": [ # self.examHelper.referenced_question_retrievers[0], # self.examHelper.referenced_question_retrievers[1], # self.examHelper.referenced_question_retrievers[2], # ] # } # ]} # # (response_data, status_code, error_message) = self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, expected_questions_count=3, validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # # duplicate group name # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345679, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], # rules=rules, # validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertIn('rules', response_data['fields'], error_message) # self.assertEqual('Duplicate group name "math1"', # response_data['fields']['rules'], error_message) # # # duplicate group id # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [self.examHelper.referenced_question_retrievers[0]] # }, # { # "id": 12345678, # "name": "math2", # "questions": [self.examHelper.referenced_question_retrievers[1]] # } # ]} # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], # rules=rules, # validate_success=False) # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertIn('rules', response_data['fields'], error_message) # self.assertEqual('Duplicate group id "12345678"', # response_data['fields']['rules'], error_message) # # # delayable=True but max_delay=None # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False, public=True, # delayable=True, max_delay=None) # self.assertEqual('validation_error', # response_data['status'], error_message) # # delayable=False but max_delay="00:09:00" # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False, public=True, # delayable=False, max_delay="00:09:00") # # this API should actually return error. But instead, we just ignore the max_delay field. # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn( # 'max_delay', response_data['data']['exam'], error_message) # self.assertIsNone(response_data['data'] # ['exam']['max_delay'], error_message) # # def test_get_exam_and_exam_template_group_success(self): # self.examHelper.generate_referenced_question_retrievers( # self.institute['id']) # self.examHelper.generate_query_question_list_by_filtering_list( # self.institute['id']) # # rules = {'groups': [ # { # "id": 12345678, # "name": "math1", # "questions": [ # self.examHelper.referenced_question_retrievers[0], # self.examHelper.referenced_question_retrievers[1], # self.examHelper.query_question_list_by_filtering_object[0] # ] # }, # { # "id": 12345679, # "name": "math2", # "questions": [self.examHelper.referenced_question_retrievers[2]] # } # ]} # (exam_id, public_id) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, expected_questions_count=8, # create_exam_template=True) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.get_exam_group, { # 'exam_id': exam_id, # 'group_id': 12345678 # }) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn('group', response_data['data'], error_message) # self.assertEqual( # 3, len(response_data['data']['group']['questions']), error_message) # self.assertEqual( # 'math1', response_data['data']['group']['name'], error_message) # self.assertEqual( # 12345678, response_data['data']['group']['id'], error_message) # self.assertEqual(self.examHelper.referenced_question_retrievers[0]['question_id'], # response_data['data']['group']['questions'][0]['question_object']['id'], error_message) # self.assertEqual(self.examHelper.referenced_question_retrievers[1]['question_id'], # response_data['data']['group']['questions'][1]['question_object']['id'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.get_exam_template_group, { # 'exam_template_id': ExamTemplate.objects.first().id, # 'group_id': 12345678 # }) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn('group', response_data['data'], error_message) # self.assertEqual( # 3, len(response_data['data']['group']['questions']), error_message) # self.assertEqual( # 'math1', response_data['data']['group']['name'], error_message) # self.assertEqual( # 12345678, response_data['data']['group']['id'], error_message) # self.assertEqual(self.examHelper.referenced_question_retrievers[0]['question_id'], # response_data['data']['group']['questions'][0]['question_object']['id'], error_message) # self.assertEqual(self.examHelper.referenced_question_retrievers[1]['question_id'], # response_data['data']['group']['questions'][1]['question_object']['id'], error_message) # # def test_create_exam_serializer_error(self): # # rules without groups # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create, { # 'context_institute_id': self.institute['id'], # 'name': self.examHelper.new_name(), # 'rules': json.dumps({}), # 'report_card_strategy': 'manual', # 'theme': 'dark', # "finish_message": 'test' # }) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertIn('rules', response_data['fields'], error_message) # self.assertEqual("valid 'groups' was not found in rules. rules must only contain groups(list)*.", # response_data['fields']['rules'], error_message) # # # rules without questions # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create, { # 'context_institute_id': self.institute['id'], # 'name': self.examHelper.new_name(), # "finish_message": 'test', # 'rules': json.dumps({'groups': [ # { # "id": 12345678, # "name": "math1" # } # ]}), # 'report_card_strategy': 'manual', # 'theme': 'dark' # }) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertIn('rules', response_data['fields'], error_message) # self.assertEqual( # "valid 'questions' was not found in one of the items in groups. Each item in groups must only contain id(int)*, name(str)*, questions(list)*.", # response_data['fields']['rules'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create, { # 'context_institute_id': self.institute['id'], # 'name': self.examHelper.new_name(), # "finish_message": 'test', # 'rules': json.dumps({'groups': [ # { # "id": 12345678, # "name": "math1" # } # ]}), # 'report_card_strategy': 'on_date_time', # 'theme': 'dark' # }) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # # def test_edit_exam_success(self): # # all tests are identical regarding override_institute_logo and poster # with open('test_files/image.png', 'rb') as fp1, open('test_files/image.png', 'rb') as fp2: # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, reanswer=True, # shuffle_questions=True, shuffle_answers=True, # one_question_at_a_time=True, override_institute_logo=fp1, # poster=fp2, override_institute_name='new_name', # create_exam_template=True, start_date=timezone.now(), # end_date=timezone.now() + timedelta(days=2), duration='01:00:12', # finish_message='test1', theme='light', description='test') # # with open('test_files/image.png', 'rb') as fp1, open('test_files/image.png', 'rb') as fp2: # # ordinary update # self.examHelper.edit_exam_helper(self.institute['id'], exam_id, public=False, reanswer=False, shuffle_questions=False, # shuffle_answers=False, one_question_at_a_time=False, override_institute_logo=fp1, # poster=fp2, override_institute_name='new_name2', start_date=timezone.now(), # end_date=timezone.now() + timedelta(days=1), duration='02:00:06', finish_message='test123', # theme='dark', description='hello') # # # also delete the override_institute_logo and clearing override_institute_name by sending empty string # self.examHelper.edit_exam_helper(self.institute['id'], exam_id, public=False, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, delete_override_institute_logo=True, # delete_poster=True, override_institute_name='') # # edit delayable=True and max_delay='1:20:34' # self.examHelper.edit_exam_helper(self.institute['id'], exam_id, public=False, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, delete_override_institute_logo=True, # delete_poster=True, override_institute_name='', delayable=True, max_delay='1:20:34') # # edit subscription_required=True and price=50000 # self.examHelper.edit_exam_helper(self.institute['id'], exam_id, public=False, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, delete_override_institute_logo=True, # delete_poster=True, override_institute_name='', price=50000) # # with open('test_files/image.png', 'rb') as fp1, open('test_files/image.png', 'rb') as fp2: # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, reanswer=True, # shuffle_questions=True, shuffle_answers=True, # one_question_at_a_time=True, override_institute_logo=fp1, # poster=fp2, override_institute_name='new_name', # create_exam_template=True, delayable=True, max_delay='3:34:00', # price=30000) # # edit subscription_required=False and price = 45000 # self.examHelper.edit_exam_helper(self.institute['id'], exam_id, public=False, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, delete_override_institute_logo=True, # delete_poster=True, override_institute_name='', delayable=False, # price=45000) # # # TODO more complex edit and delete tests # # TODO using a deleted exam in page/get and cover and enter, ... # def test_delete_exam_success(self): # exam_id, public_id = self.examHelper.create_exam_helper( # self.institute['id'], public=True, create_exam_template=False) # self.examHelper.archive_quiz_helper(exam_id) # # exam_id, public_id = self.examHelper.create_exam_helper( # self.institute['id'], public=False, create_exam_template=True, name='test') # self.examHelper.archive_quiz_helper(exam_id) # # def test_delete_exam_error(self): # exam_id, public_id = self.examHelper.create_exam_helper( # self.institute['id'], public=True, create_exam_template=False) # self.examHelper.archive_quiz_helper(exam_id) # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # self.assertEqual(404, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('The exam has been deleted', # response_data['message'], error_message) # # def test_list_exam_success(self): # # creating an active exam # start_date = timezone.now() - timedelta(seconds=1) # end_date = timezone.now() + timedelta(minutes=3) # self.examHelper.create_exam_helper( # self.institute['id'], name='present1', start_date=start_date, end_date=end_date) # # # creating an active exam without end_date # start_date = timezone.now() - timedelta(seconds=1) # self.examHelper.create_exam_helper( # self.institute['id'], name='present2', start_date=start_date) # # # creating an active exam without start_date #12264 after next creation # # # creating an exam that has not yet started # start_date = timezone.now() + timedelta(days=7) # end_date = timezone.now() + timedelta(days=14) # # this exam will be modified later # (exam_id, public_id) = self.examHelper.create_exam_helper(self.institute['id'], name='future__temp', start_date=start_date, # end_date=end_date) # # # creating an active exam without start_date #12264 # end_date = timezone.now() + timedelta(minutes=3) # self.examHelper.create_exam_helper( # self.institute['id'], name='present3', end_date=end_date) # # # creating an exam that has passed # start_date = timezone.now() - timedelta(days=14) # end_date = timezone.now() - timedelta(days=7) # self.examHelper.create_exam_helper( # self.institute['id'], name='past', start_date=start_date, end_date=end_date) # # creating an infinite # self.examHelper.create_exam_helper( # self.institute['id'], name='infinite') # self.examHelper.edit_exam_helper( # self.institute['id'], exam_id, name='future') # # # testing created_at_asc sort # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'created_at_asc', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(6, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'present1', response_data['data']['exams'][0]['name'], error_message) # self.assertEqual( # 'present2', response_data['data']['exams'][1]['name'], error_message) # self.assertEqual( # 'future', response_data['data']['exams'][2]['name'], error_message) # self.assertEqual( # 'present3', response_data['data']['exams'][3]['name'], error_message) # self.assertEqual( # 'past', response_data['data']['exams'][4]['name'], error_message) # self.assertEqual( # 'infinite', response_data['data']['exams'][5]['name'], error_message) # # # testing name_asc sort # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(6, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'future', response_data['data']['exams'][0]['name'], error_message) # self.assertEqual( # 'infinite', response_data['data']['exams'][1]['name'], error_message) # self.assertEqual( # 'past', response_data['data']['exams'][2]['name'], error_message) # self.assertEqual( # 'present1', response_data['data']['exams'][3]['name'], error_message) # self.assertEqual( # 'present2', response_data['data']['exams'][4]['name'], error_message) # self.assertEqual( # 'present3', response_data['data']['exams'][5]['name'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'q': 'fu', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'future', response_data['data']['exams'][0]['name'], error_message) # # # testing active filter # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'active_filter': 'present', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(4, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'infinite', response_data['data']['exams'][0]['name'], error_message) # self.assertEqual( # 'present1', response_data['data']['exams'][1]['name'], error_message) # self.assertEqual( # 'present2', response_data['data']['exams'][2]['name'], error_message) # self.assertEqual( # 'present3', response_data['data']['exams'][3]['name'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'active_filter': 'past', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'past', response_data['data']['exams'][0]['name'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'active_filter': 'future', # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, len(response_data['data']['exams']), error_message) # self.assertEqual( # 'future', response_data['data']['exams'][0]['name'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'active_filter': 'future', # 'reanswer_filter': 'exclude', # 'shuffle_questions_filter': 'exclude', # 'shuffle_answers_filter': 'exclude', # "one_question_at_a_time_filter": "exclude", # 'deleted_filter': 'exclude' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(0, len(response_data['data']['exams']), error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'sort_by': 'name_asc', # 'active_filter': 'future', # 'reanswer_filter': 'only', # 'shuffle_questions_filter': 'only', # 'shuffle_answers_filter': 'only', # "one_question_at_a_time_filter": "only", # 'deleted_filter': 'only' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(0, len(response_data['data']['exams']), error_message) # # def test_create_exam_template_success(self): # with open('test_files/image.png', 'rb') as fp1: # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, # create_exam_template=False, poster=fp1) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create_quiz_template, { # 'exam_id': exam_id # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_list_and_get_exam_template_success(self): # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, # create_exam_template=True, ) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create_quiz_template, { # 'exam_id': exam_id, # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list_quiz_template, { # 'institute_id': self.institute['id'], # 'skip': 0, # 'take': 10, # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include', # # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 2, len(response_data['data']['exam_templates']), error_message) # self.assertIn('id', response_data['data'] # ['exam_templates'][0], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.get_quiz_template, { # 'exam_template_id': response_data['data']['exam_templates'][0]['id'] # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn( # 'rules', response_data['data']['exam_template'], error_message) # # def test_list_and_get_public_exam_template_success(self): # PublicExamTemplate.objects.create( # name='public_exam_template2', # priority=2, # theme='dark', # description='abc', # apply_negative_scores=True, # questions_count=10, # rules={'groups': []}, # delayable=False # ) # # PublicExamTemplate.objects.create( # name='public_exam_template1', # priority=1, # theme='dark', # description='abc', # apply_negative_scores=True, # questions_count=10, # rules={'groups': []}, # delayable=False # ) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list_public_exam_template, { # 'skip': 0, # 'take': 10, # 'reanswer_filter': 'include', # 'shuffle_questions_filter': 'include', # 'shuffle_answers_filter': 'include', # "one_question_at_a_time_filter": "include", # 'deleted_filter': 'include' # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 2, len(response_data['data']['public_exam_templates']), error_message) # self.assertEqual('public_exam_template1', # response_data['data']['public_exam_templates'][0]['name'], error_message) # # self.assertIn( # 'id', response_data['data']['public_exam_templates'][0], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.get_public_exam_template, { # 'public_exam_template_id': response_data['data']['public_exam_templates'][0]['id'] # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn( # 'rules', response_data['data']['public_exam_template'], error_message) # # # sending a non existence public_exam_template_id # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.get_public_exam_template, { # 'public_exam_template_id': self.non_existence_uuid # }, application_json=True) # self.assertEqual(404, status_code, error_message) # self.assertEqual('not_found', response_data['status'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list_public_exam_template, { # 'skip': 0, # 'take': 10, # 'q': 'test', # 'reanswer_filter': 'exclude', # 'shuffle_questions_filter': 'exclude', # 'shuffle_answers_filter': 'exclude', # "one_question_at_a_time_filter": "exclude", # 'deleted_filter': 'exclude' # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 0, len(response_data['data']['public_exam_templates']), error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.list_public_exam_template, { # 'skip': 0, # 'take': 10, # 'q': 'test', # 'reanswer_filter': 'only', # 'shuffle_questions_filter': 'only', # 'shuffle_answers_filter': 'only', # "one_question_at_a_time_filter": "only", # 'deleted_filter': 'only' # }, application_json=True) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 0, len(response_data['data']['public_exam_templates']), error_message) # # # this test contains both QueryQuestionObjectById and QueryQuestionListByFiltering inside the default rules attribute # def test_generate_exam_page_for_institute_student_success(self): # start_date = timezone.now() # end_date = timezone.now() + timedelta(days=7) # duration = "01:20:00" # # # with start_date and end_date and duration # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # start_date=start_date, # end_date=end_date, # duration=duration, # ) # # # without duration # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # start_date=start_date, # end_date=end_date # ) # # # without end_date # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # start_date=start_date, # duration=duration # ) # # # without start_date # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # end_date=end_date, # duration=duration # ) # # # without start_date and duration # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # end_date=end_date # ) # # # without start_date and end_date # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # duration=duration # ) # # # without end_date and duration # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'], # start_date=start_date # ) # # # without start_date and end_date and duration # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id'] # ) # # def test_get_exam_page_by_institute_student_success(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # exam_page_id, entrance_token = self.examHelper.generate_quiz_sheet_for_institute_student_helper(self.institute['id'], # start_date, end_date) # # # getting an exam before scores_published # (response_data, status_code, error_message) = self.post_without_token(self.examHelper.institute_student_exam_page_get, { # 'entrance_token': entrance_token, # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn( # 'state', response_data['data']['exam_page'], error_message) # self.assertIn( # 'start_date', response_data['data']['exam_page'], error_message) # self.assertIn( # 'end_date', response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'final_score', response_data['data']['exam_page'], error_message) # self.assertNotIn('generated_exam', # response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'user_inputs', response_data['data']['exam_page'], error_message) # self.assertIsNotNone( # response_data['data']['exam']['institute']['on_exam_finished_redirect_url'], error_message) # self.assertNotIn('corrections', response_data['data'], error_message) # # # TODO getting an exam after scores_published # # self.assertEqual(200, status_code, error_message) # # self.assertEqual('ok', response_data['status'], error_message) # # self.assertIn('status', response_data['data']['exam_page'], error_message) # # self.assertIn('start_date', response_data['data']['exam_page'], error_message) # # self.assertIn('end_date', response_data['data']['exam_page'], error_message) # # self.assertIn('final_score', response_data['data']['exam_page'], error_message) # # self.assertIn('generated_exam', response_data['data']['exam_page'], error_message) # # self.assertIn('user_inputs', response_data['data']['exam_page'], error_message) # # self.assertIsNotNone(response_data['data']['redirect_url'], error_message) # # self.assertIn('corrections', response_data['data'], error_message) # # def test_get_exam_page_by_institute_student_error(self): # self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id']) # # (response_data, status_code, error_message) = self.post_without_token(self.examHelper.institute_student_exam_page_get, { # 'entrance_token': "invalid_entrance_token", # }) # self.assertEqual(401, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # # # TODO also test for public exams # def test_enter_a_reanswerable_exam_page_by_institute_student_success(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # attending an exam in the start_date and end_date range # self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date, # end_date) # # # start_date and end_date and duration # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # duration = "01:20:00" # # self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date, # end_date, # duration) # # # start_date and end_date and duration and max_delay # start_date = timezone.now() - timedelta(days=1) # end_date = timezone.now() + timedelta(days=2) # duration = "01:20:00" # max_delay = "0:20:00" # # self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date=start_date, # end_date=end_date, # duration=duration, # max_delay=max_delay, # delayable=True) # # # start_date # start_date = timezone.now() - timedelta(days=7) # self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date) # # def test_enter_a_not_reanswerable_exam_page_by_institute_student_success(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # attending an exam in the start_date and end_date range # self.examHelper.enter_exam_helper(self.institute['id'], start_date, end_date, reanswer=False, # one_question_at_a_time=False) # # def test_enter_an_exam_page_by_institute_student_error(self): # # TODO enter exam with wrong entrance_token # # TODO enter exam with wrong entrance_ip # start_date = timezone.now() + timedelta(days=1) # end_date = timezone.now() + timedelta(days=7) # # entering an exam before it starts # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date, # end_date, # validate_success=False) # # self.assertEqual('exam_not_started', # response_data['status'], error_message) # self.assertEqual('Exam is not started.', # response_data['message'], error_message) # self.assertIsNotNone( # response_data['data']['exam_page']['start_date'], error_message) # self.assertNotIn( # 'final_score', response_data['data']['exam_page'], error_message) # self.assertNotIn('generated_exam', # response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'user_inputs', response_data['data']['exam_page'], error_message) # self.assertNotIn('corrections', response_data['data'], error_message) # # def test_final_end_date_error(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() - timedelta(days=4) # # 6735673855 # # entering an exam after its end without delay # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date, # end_date, # validate_success=False) # # self.assertEqual('exam_ended', response_data['status'], error_message) # self.assertEqual('Exam has ended.', # response_data['message'], error_message) # self.assertIsNotNone( # response_data['data']['exam_page']['end_date'], error_message) # self.assertNotIn( # 'final_score', response_data['data']['exam_page'], error_message) # self.assertNotIn('generated_exam', # response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'user_inputs', response_data['data']['exam_page'], error_message) # self.assertNotIn('corrections', response_data['data'], error_message) # # # entering an exam after its end with delay # start_date = timezone.now() - timedelta(days=2) # end_date = timezone.now() - timedelta(days=1) # # this test will cover line # 3616372662 and checks the error case # max_delay = "23:59:59" # # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # ENTRANCE_TYPE_API_INVITE, # start_date=start_date, # end_date=end_date, # delayable=True, # max_delay=max_delay, # validate_success=False) # # self.assertEqual('exam_ended', response_data['status'], error_message) # self.assertEqual('Exam has ended.', # response_data['message'], error_message) # self.assertIsNotNone( # response_data['data']['exam_page']['end_date'], error_message) # self.assertNotIn( # 'final_score', response_data['data']['exam_page'], error_message) # self.assertNotIn('generated_exam', # response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'user_inputs', response_data['data']['exam_page'], error_message) # self.assertNotIn('corrections', response_data['data'], error_message) # ########################################################## # # start_date = timezone.now() - timedelta(days=2) # end_date = timezone.now() + timedelta(days=6) # # this duration will test the # 1736756273 line # duration = "01:50:50" # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # start_date=start_date, # end_date=end_date, # duration=duration, # max_delay=max_delay, # reanswer=False, # one_question_at_a_time=False, # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # self.assertEqual( # 'exam_ended', response_data['status'], error_message) # self.assertEqual('Exam has ended.', # response_data['message'], error_message) # self.assertIsNotNone( # response_data['data']['exam_page']['end_date'], error_message) # self.assertNotIn( # 'final_score', response_data['data']['exam_page'], error_message) # self.assertNotIn('generated_exam', # response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'user_inputs', response_data['data']['exam_page'], error_message) # self.assertNotIn( # 'corrections', response_data['data'], error_message) # ################################################# # # def test_get_question_for_a_reanswerable_exam_page_success_and_error(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # this duration will test the # 3616372662 line for the success case # duration = "20 01:20:00" # # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # start_date=start_date, # end_date=end_date, # duration=duration, # reanswer=True, # one_question_at_a_time=False, # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # self.examHelper.get_question_helper( # device_token, 0, 1, entrance_token=entrance_token, public_id=public_id) # # # get a question that does not exist # self.examHelper.get_question_helper(device_token, 0, 100, entrance_token=entrance_token, public_id=public_id, # should_return_not_found_error=True, first_available_question_index=1, # first_available_group_index=0) # # # get a question in a group that does not exist # self.examHelper.get_question_helper(device_token, 100, 0, entrance_token=entrance_token, public_id=public_id, # should_return_not_found_error=True, first_available_question_index=1, # first_available_group_index=0) # # def test_get_question_for_a_not_reanswerable_exam_page_by_institute_student_success_and_error(self): # # this duration will test the # 417536827 line # end_date = None # duration = "01:20:00" # max_delay = "00:40:00" # # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # end_date=end_date, # duration=duration, # max_delay=max_delay, # reanswer=False, # one_question_at_a_time=False, # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # # get the second question in the first group, it should return access denied # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # self.examHelper.get_question_helper( # device_token, 0, 1, entrance_token=entrance_token, public_id=public_id) # # # get a question that does not exist # self.examHelper.get_question_helper(device_token, 0, 100, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True, first_available_question_index=1, # first_available_group_index=0) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 1, len(ExamPage.objects.first().user_inputs_history)) # # get a question in a group that does not exist # self.examHelper.get_question_helper(device_token, 100, 0, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True, first_available_question_index=1, # first_available_group_index=0) # # def test_get_group_for_a_not_reanswerable_exam_page_success_and_error(self): # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=False, # one_question_at_a_time=False, # rules=self.examHelper.get_general_rule2(self.institute['id']), # expected_questions_count=8 # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # self.examHelper.get_group_helper(device_token, 0, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True) # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 1, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 2, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # # get the first question in the first group # self.examHelper.get_group_helper( # device_token, 0, entrance_token=entrance_token, public_id=public_id) # # # get a question in a group that does not exist # self.examHelper.get_group_helper(device_token, 100, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True, first_available_question_index=0, # first_available_group_index=1) # # # TODO test descriptive # def test_set_answer_for_a_reanswerable_exam_page_success(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # duration = "01:20:00" # # # attending an exam in the start_date and end_date range # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=True, # one_question_at_a_time=False, # start_date=start_date, # end_date=end_date, # duration=duration, # # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # # get the second question in the first group # self.examHelper.get_question_helper( # device_token, 0, 1, entrance_token=entrance_token, public_id=public_id) # # # set the first answer # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 1, len(ExamPage.objects.first().user_inputs_history)) # # # TODO check the answer_text in the database # # we still should be able to get both questions # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # # get the second question in the first group # self.examHelper.get_question_helper( # device_token, 0, 1, entrance_token=entrance_token, public_id=public_id) # # # re set the first answer # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 2, len(ExamPage.objects.first().user_inputs_history)) # # # TODO check the answer_text in the database # # # set all three answers together # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}, # {'group_index': 0, 'question_index': 1, 'answer_indexes': [ # 1, 2]}, # {'group_index': 0, 'question_index': 2, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id) # # self.assertEqual(3, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 3, len(ExamPage.objects.first().user_inputs_history)) # # ExamPage.objects.all().delete() # # # TODO check the answer_text in the database # # def test_set_answer_file_for_a_not_reanswerable_exam_page_error(self): # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # # rules will be multiple-choice # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=False, # one_question_at_a_time=False # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # with open('test_files/image.png', 'rb') as fp1: # # question is not descriptive so we cannot upload a file # self.examHelper.answer_file_helper(device_token, group_index=0, question_index=0, file=fp1, public_id=public_id, # entrance_token=entrance_token, error_400=True) # # with open('test_files/image.png', 'rb') as fp1: # # question is not descriptive but the server should not return any information about te type of the next question. So, it only returns an index_error # self.examHelper.answer_file_helper(device_token, group_index=0, question_index=1, file=fp1, public_id=public_id, # entrance_token=entrance_token, error_409=True) # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # with open('test_files/image.png', 'rb') as fp1: # # question is not descriptive so we cannot upload a file # self.examHelper.answer_file_helper(device_token, group_index=0, question_index=1, file=fp1, public_id=public_id, # entrance_token=entrance_token, error_400=True) # # def test_set_answer_file_for_a_not_reanswerable_exam_page_success(self): # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # rules = self.examHelper.get_genera_descriptive_rule( # self.institute['id']) # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=False, # one_question_at_a_time=False, # rules=rules, # expected_questions_count=3 # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # with open('test_files/image.png', 'rb') as fp1: # # question is not descriptive so we cannot upload a file # self.examHelper.answer_file_helper(device_token, group_index=0, question_index=0, file=fp1, public_id=public_id, # entrance_token=entrance_token) # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps([{'group_index': 0, 'question_index': 0, 'answer_text': 'test', # 'answer_text_format': 'htmlV1'}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # with open('test_files/image.png', 'rb') as fp1: # # question is not descriptive so we cannot upload a file # # (response_data, status_code, error_message) = self.examHelper.answer_file_helper(device_token, group_index=0, # question_index=1, file=fp1, # public_id=public_id, # entrance_token=entrance_token) # # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps([{'group_index': 0, 'question_index': 1, 'answer_text': 'test', # 'answer_text_format': 'htmlV1'}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # self.examHelper.delete_answer_file_helper(file_id=response_data['data']['answer_file']['id'], device_token=device_token, # group_index=0, question_index=1, entrance_token=entrance_token, public_id=public_id) # # def test_set_answer_for_a_not_reanswerable_exam_page_success_and_error(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # attending an exam in the start_date and end_date range # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=False, # one_question_at_a_time=False, # start_date=start_date, # end_date=end_date # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # # get the second question in the first group # self.examHelper.get_question_helper(device_token, 0, 1, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True) # # set the first answer but do not set go_to_next_question # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=False) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 1, len(ExamPage.objects.first().user_inputs_history)) # # # we still should not be able to get this question # self.examHelper.get_question_helper(device_token, 0, 1, entrance_token=entrance_token, public_id=public_id, # should_return_index_error=True) # # # set the first answer again but with go_to_next_question=True # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, go_to_next_question=True) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 2, len(ExamPage.objects.first().user_inputs_history)) # # # now we should be able to get both questions # # get the first question in the first group # self.examHelper.get_question_helper( # device_token, 0, 0, entrance_token=entrance_token, public_id=public_id) # # # get the second question in the first group # self.examHelper.get_question_helper( # device_token, 0, 1, entrance_token=entrance_token, public_id=public_id) # # # re set the first answer # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, should_return_index_error=True, # first_available_question_index=1, first_available_group_index=0) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 2, len(ExamPage.objects.first().user_inputs_history)) # # # set all three answers together # self.examHelper.exam_page_set_answer_helper(device_token, # json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}, # {'group_index': 0, 'question_index': 1, 'answer_indexes': [ # 1, 2]}, # {'group_index': 0, 'question_index': 2, 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, public_id=public_id, error_400=True) # # self.assertEqual(1, len(ExamPage.objects.first().user_inputs)) # self.assertEqual( # 2, len(ExamPage.objects.first().user_inputs_history)) # # ExamPage.objects.all().delete() # # def test_set_answer_for_exam_page_error(self): # start_date = timezone.now() - timedelta(days=7) # end_date = timezone.now() + timedelta(days=7) # # attending an exam in the start_date and end_date range # for entrance_type in ALLOWED_ENTRANCE_TYPES: # public_id = None # entrance_token = None # # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], # entrance_type, # reanswer=True, # one_question_at_a_time=False, # start_date=start_date, # end_date=end_date # ) # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # # without any token # self.examHelper.exam_page_set_answer_helper(device_token='ijdijie2', user_inputs=json.dumps( # [{'group_index': 0, 'question_index': 0, 'answer_indexes': [1, 2]}, ]), entrance_token=entrance_token, public_id=public_id, # error_401=True) # # # without user_inputs # self.examHelper.exam_page_set_answer_helper(device_token, user_inputs='effrg', entrance_token=entrance_token, # public_id=public_id, # error_400=True, message='Some fields are not valid', status='validation_error') # # self.examHelper.exam_page_set_answer_helper(device_token, user_inputs=json.dumps( # [{'group_index': 1, 'question_index': 'wrong_question_index', 'answer_indexes': [1, 2]}]), # entrance_token=entrance_token, # public_id=public_id, # error_400=True, message='Some fields are not valid', status='validation_error') # # def test_finish_exam_page_success(self): # for entrance_type in ALLOWED_ENTRANCE_TYPES: # # test with apply_negative_scores=True # self.examHelper.finish_an_exam_page_with_answers( # institute_id=self.institute['id'], entrance_type=entrance_type, apply_negative_scores=True) # # # test with apply_negative_scores=False # self.examHelper.finish_an_exam_page_with_answers( # institute_id=self.institute['id'], entrance_type=entrance_type, apply_negative_scores=False) # # # test with shuffle all # self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], entrance_type=entrance_type, # shuffle_questions=True, # shuffle_answers=True, apply_negative_scores=True) # # # test with only shuffle_questions and reanswer=False # self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], entrance_type=entrance_type, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False, apply_negative_scores=True) # # def test_institute_student_finish_exam_page_redirect_url_Successful(self): # # institute = Institute.objects.get(id=self.institute['id']) # institute.on_exam_finished_redirect_url = "http://google.com" # institute.save() # (response_data, status_code, error_message) = self.examHelper.institute_student_finish_exam_page_helper(institute_id=institute.id, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # self.assertEqual('ok', response_data['status'], error_message) # # institute.on_exam_finished_redirect_url = "http://google.com?" # institute.save() # (response_data, status_code, error_message) = self.examHelper.institute_student_finish_exam_page_helper(institute_id=institute.id, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # self.assertEqual('ok', response_data['status'], error_message) # institute.on_exam_finished_redirect_url = "" # institute.save() # (response_data, status_code, error_message) = self.examHelper.institute_student_finish_exam_page_helper(institute_id=institute.id, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # self.assertEqual('ok', response_data['status'], error_message) # # def test_create_public_exam_success(self): # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # self.examHelper.create_exam_helper( # self.institute['id'], rules=rules, public=True, expected_questions_count=3) # # # TODO change a public exam to private and vice versa # # subscription_required=True price=50000 # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # self.examHelper.create_exam_helper(self.institute['id'], rules=rules, public=True, price=50000, # expected_questions_count=3) # # # subscription_required=True price=0 # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # self.examHelper.create_exam_helper(self.institute['id'], rules=rules, public=True, price=0, # expected_questions_count=3) # # # subscription_required=True price=None None = 0 Null is the same as 0 # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False, public=True, # price=None) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn('price', response_data['data']['exam'], error_message) # # def test_create_public_exam_error(self): # # price=50000 # rules = self.examHelper.get_only_referenced_question_rule( # self.institute['id']) # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False, public=True, price=50000) # self.assertEqual('ok', response_data['status'], error_message) # self.assertIn('price', response_data['data']['exam'], error_message) # self.assertEqual( # 50000, response_data['data']['exam']['price'], error_message) # # (response_data, status_code, error_message) = self.examHelper.create_exam_helper(self.institute['id'], rules=rules, # validate_success=False, public=True, # price=-10000) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Ensure this value is greater than or equal to 0.', # response_data['fields']['price'], error_message) # # def test_get_exam_cover_success(self): # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=60000) # # getting an exam_page cover before it is generated # exam_id, public_id = self.examHelper.create_exam_helper( # self.institute['id'], public=True, price=10000) # # cover_keys will be sent to later tests and we will check that # # all cover APIs(public/cover and institute_student/cover) will return the same set of keys # cover_keys = self.examHelper.get_exam_cover_helper( # quiz_sheet_id=None, public_id=public_id, device_token=None) # # # getting an exam_page cover before attendance # exam_page_id, entrance_token = self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id']) # self.examHelper.get_exam_cover_helper(quiz_sheet_id=entrance_token, public_id=None, device_token=None, # expected_cover_keys=cover_keys) # # for entrance_type in ALLOWED_ENTRANCE_TYPES: # # getting an exam_page cover before scores_published # (exam_page_id, _2, device_token) = self.examHelper.enter_exam_helper( # self.institute['id'], entrance_type) # # entrance_token = None # public_id = None # if entrance_type == ENTRANCE_TYPE_PUBLIC: # public_id = _2 # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # entrance_token = _2 # else: # continue # # self.examHelper.get_exam_cover_helper(quiz_sheet_id=entrance_token, public_id=public_id, device_token=device_token, # expected_cover_keys=cover_keys) # # # TODO getting an exam after scores_published using device token # # # def test_enter_a_reanswerable_public_exam_page_success(self): # # self.examHelper.enter_public_exam_helper(self.institute['id']) # # def test_exam_cover_invalid_in_progress_state(self): # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=60000) # # getting an exam_page cover before it is generated # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, # reanswer=False, # shuffle_questions=True, shuffle_answers=True, one_question_at_a_time=True, start_date=timezone.now() - timedelta(days=2), end_date=timezone.now() + timedelta(days=1)) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 'in_progress', response_data['data']['exam_page']['state'], error_message) # # exam_page = ExamPage.objects.get( # id=response_data['data']['exam_page']['id']) # exam_page.end_date = timezone.now() - timedelta(days=4) # exam_page.save() # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_cover, { # 'public_id': public_id, 'device_token': response_data['data']['device_token']}) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual('scores_published', # response_data['data']['state'], error_message) # ################################################################################################ # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=60000) # # getting an exam_page cover before it is generated # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, # reanswer=False, # shuffle_questions=True, shuffle_answers=True, one_question_at_a_time=True, start_date=timezone.now(), duration="00:10:00") # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 'in_progress', response_data['data']['exam_page']['state'], error_message) # # exam_page = ExamPage.objects.get( # id=response_data['data']['exam_page']['id']) # exam_page.entrance_date = timezone.now() - timedelta(minutes=20) # exam_page.save() # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_cover, { # 'public_id': public_id, 'device_token': response_data['data']['device_token']}) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual('scores_published', # response_data['data']['state'], error_message) # # def test_generate_invoice_success(self): # # TODO ENTRANCE_TYPE_API_INVITE and ENTRANCE_TYPE_ADMIN_INVITE # for entrance_type in [ENTRANCE_TYPE_PUBLIC]: # # get invoice for an exam with price=10000 # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], # public=True if entrance_type == ENTRANCE_TYPE_PUBLIC else False, # price=10000) # # self.examHelper.generate_invoice_helper( # public_id=public_id, expected_total_cost=12208) # # # get invoice for an exam with price=0 # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], # public=True if entrance_type == ENTRANCE_TYPE_PUBLIC else False, # price=0) # # self.examHelper.generate_invoice_helper( # public_id=public_id, expected_total_cost=1090) # # def test_enter_public_business_error(self): # # balance is not enough # # wage and tax will be added to exam price # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=10000) # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # price=10000, validate_success=False, # send_token=True) # # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('balance is not enough', # response_data['message'], error_message) # self.assertEqual(10000, UserBalanceHistory.objects.order_by( # 'created_at').last().remaining_balance, error_message) # # # enter a subscription_required exam without token # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # price=50000, validate_success=False, # send_token=False) # # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual( # 'Access denied', response_data['message'], error_message) # # def test_enter_public_business_success(self): # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=12208) # # user does not have any plan # (response_data, status_code, error_message) = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # price=10000, validate_success=False) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # # last_user_balance = UserBalanceHistory.objects.order_by( # 'created_at').last() # last_institute_balance = InstituteBalanceHistory.objects.order_by( # 'created_at').last() # last_wikiazma_balance = WikiazmaBalanceHistory.objects.order_by( # 'created_at').last() # # self.assertEqual(0, last_user_balance.remaining_balance, error_message) # self.assertEqual(ExamPurchase, last_user_balance.reason, error_message) # self.assertEqual( # 10000, last_institute_balance.remaining_balance, error_message) # self.assertEqual( # ExamPurchase, last_institute_balance.reason, error_message) # self.assertEqual(10000, last_institute_balance.amount, error_message) # self.assertIsNotNone(last_institute_balance.exam, error_message) # self.assertEqual({'exam_page_id': response_data['data']['exam_page']['id']}, # last_institute_balance.reason_meta_data, error_message) # # Wikiazma BalanceHistory # self.assertEqual(2208, last_wikiazma_balance.remaining_balance) # self.assertEqual(ExamPurchase, last_wikiazma_balance.reason) # self.assertIsNone(last_wikiazma_balance.institute) # self.assertIsNotNone(last_wikiazma_balance.user) # # # user buys an exam again # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=30000) # exam_page_id, public_id, device_token = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # price=10000) # # last_user_balance = UserBalanceHistory.objects.order_by( # 'created_at').last() # last_institute_balance = InstituteBalanceHistory.objects.order_by( # 'created_at').last() # last_wikiazma_balance = WikiazmaBalanceHistory.objects.order_by( # 'created_at').last() # # self.assertEqual( # 17792, last_user_balance.remaining_balance, error_message) # self.assertEqual(10000, last_institute_balance.amount, error_message) # self.assertEqual( # 20000, last_institute_balance.remaining_balance, error_message) # # exam tax has been added to wikiazma # self.assertEqual(4416, last_wikiazma_balance.remaining_balance) # # # user has the exam. So, balance should stay fixed. # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # 'device_token': device_token, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # # last_user_balance = UserBalanceHistory.objects.order_by( # 'created_at').last() # last_institute_balance = InstituteBalanceHistory.objects.order_by( # 'created_at').last() # last_wikiazma_balance = WikiazmaBalanceHistory.objects.order_by( # 'created_at').last() # # self.assertEqual( # 17792, last_user_balance.remaining_balance, error_message) # self.assertEqual(10000, last_institute_balance.amount, error_message) # self.assertEqual( # 20000, last_institute_balance.remaining_balance, error_message) # self.assertEqual(4416, last_wikiazma_balance.remaining_balance) # # def test_get_exam_stat_success(self): # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=10000000) # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, # reanswer=False, # shuffle_questions=True, shuffle_answers=True, one_question_at_a_time=True) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.stat, { # 'exam_id': exam_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('exam_pages', response_data['data'], error_message) # self.assertEqual( # 0, len(response_data['data']['exam_pages']), error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.stat, { # 'exam_id': exam_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('exam_pages', response_data['data'], error_message) # self.assertEqual( # 1, len(response_data['data']['exam_pages']), error_message) # self.assertIn( # 'final_score', response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'state', response_data['data']['exam_pages'][0], error_message) # self.assertIn('entrance_date', # response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'report_card', response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'user', response_data['data']['exam_pages'][0], error_message) # self.assertIn('institute_student', # response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'corrections', response_data['data']['exam_pages'][0], error_message) # # self.assertIsNotNone(response_data['data']['exam_pages'][0]['user'], error_message) # self.assertIsNone( # response_data['data']['exam_pages'][0]['institute_student'], error_message) # self.assertIsNone( # response_data['data']['exam_pages'][0]['report_card'], error_message) # self.assertEqual( # 'in_progress', response_data['data']['exam_pages'][0]['state'], error_message) # self.assertEqual( # 0, len(response_data['data']['exam_pages'][0]['corrections']), error_message) # # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # exam_id = ExamPage.objects.get(id=exam_page_id).exam_id # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.stat, { # 'exam_id': exam_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('exam_pages', response_data['data'], error_message) # self.assertEqual( # 1, len(response_data['data']['exam_pages']), error_message) # self.assertIn( # 'final_score', response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'state', response_data['data']['exam_pages'][0], error_message) # self.assertIn('entrance_date', # response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'report_card', response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'user', response_data['data']['exam_pages'][0], error_message) # self.assertIn('institute_student', # response_data['data']['exam_pages'][0], error_message) # self.assertIn( # 'corrections', response_data['data']['exam_pages'][0], error_message) # # # self.assertIsNotNone(response_data['data']['exam_pages'][0]['user'], error_message) # self.assertIsNone( # response_data['data']['exam_pages'][0]['institute_student'], error_message) # self.assertIsNotNone( # response_data['data']['exam_pages'][0]['report_card'], error_message) # self.assertEqual( # 'scores_published', response_data['data']['exam_pages'][0]['state'], error_message) # self.assertEqual( # 8, len(response_data['data']['exam_pages'][0]['corrections']), error_message) # # self.assertIn( # 'score', response_data['data']['exam_pages'][0]['corrections'][0], error_message) # self.assertIn( # 'question_id', response_data['data']['exam_pages'][0]['corrections'][0], error_message) # self.assertIn( # 'blank', response_data['data']['exam_pages'][0]['corrections'][0], error_message) # # # TODO cleanup + more tests # # ################################################################################# # def test_exam_stat_invalid_in_progress_state(self): # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=10000000) # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, # reanswer=False, # shuffle_questions=True, shuffle_answers=True, one_question_at_a_time=True, start_date=timezone.now() - timedelta(days=2), end_date=timezone.now() + timedelta(days=1)) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 'in_progress', response_data['data']['exam_page']['state'], error_message) # # exam_page = ExamPage.objects.get( # id=response_data['data']['exam_page']['id']) # exam_page.end_date = timezone.now() - timedelta(days=4) # exam_page.save() # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.stat, { # 'exam_id': exam_id, # }) # # print(response_data) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # for exam_page in response_data['data']['exam_pages']: # state = exam_page['state'] # self.assertEqual('scores_published', state, error_message) # # ########################################################################################## # UserBalanceHistory.objects.order_by( # 'created_at').update(remaining_balance=10000000) # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, # reanswer=False, # shuffle_questions=True, shuffle_answers=True, one_question_at_a_time=True, start_date=timezone.now(), duration="00:10:00") # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_enter, { # 'public_id': public_id, # }) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual( # 'in_progress', response_data['data']['exam_page']['state'], error_message) # # exam_page = ExamPage.objects.get( # id=response_data['data']['exam_page']['id']) # exam_page.entrance_date = timezone.now() - timedelta(minutes=20) # exam_page.save() # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.stat, { # 'exam_id': exam_id, # }) # # print(response_data) # # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # for exam_page in response_data['data']['exam_pages']: # state = exam_page['state'] # self.assertEqual('scores_published', state, error_message) # # def test_pause_exam_error_and_success(self): # # # TODO ENTRANCE_TYPE_ADMIN_INVITE # for entrance_type in [ENTRANCE_TYPE_PUBLIC, ENTRANCE_TYPE_API_INVITE]: # # public_id = None # entrance_token = None # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # exam_id, public_id = self.examHelper.create_exam_helper( # self.institute['id'], public=True) # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # exam_page_id, entrance_token = self.examHelper.generate_quiz_sheet_for_institute_student_helper( # self.institute['id']) # exam_id = ExamPage.objects.get(id=exam_page_id).exam_id # # else: # return # # self.examHelper.pause_exam_helper(exam_id, pause=True) # # (response_data, status_code, error_message) = self.examHelper.basic_enter_exam_helper(entrance_type, public_id=public_id, # entrance_token=entrance_token) # # self.assertEqual(400, status_code, error_message) # self.assertEqual( # 'exam_paused', response_data['status'], error_message) # self.assertEqual('The exam has paused', # response_data['message'], error_message) # # self.examHelper.pause_exam_helper(exam_id, pause=False) # # (response_data, status_code, error_message) = self.examHelper.basic_enter_exam_helper(entrance_type, public_id=public_id, # entrance_token=entrance_token) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_extend_exam_page(self): # # for entrance_type in [ENTRANCE_TYPE_PUBLIC, ENTRANCE_TYPE_API_INVITE]: # # public_id = None # entrance_token = None # # if entrance_type == ENTRANCE_TYPE_PUBLIC: # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, duration='02:00:00', # start_date=timezone.now(), # end_date=timezone.now() + timedelta(hours=10)) # elif entrance_type == ENTRANCE_TYPE_API_INVITE: # exam_page_id, entrance_token = self.examHelper.generate_quiz_sheet_for_institute_student_helper(self.institute['id'], # duration='02:00:00', # start_date=timezone.now(), # end_date=timezone.now() + timedelta( # hours=10)) # exam_id = ExamPage.objects.get(id=exam_page_id).exam_id # else: # return # # self.examHelper.basic_enter_exam_helper(entrance_type, public_id=public_id, # entrance_token=entrance_token) # # (response_data, status_code, error_message) = self.examHelper.extend_exam_page_helper(exam_id=exam_id, duration='03:00:00', # start_date=timezone.now(), # end_date=timezone.now() + timedelta( # hours=10)) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_edit_exam_template_successful_and_error(self): # # Create an exam to get ID Exam # exam_id, public_id = self.examHelper.create_exam_helper(self.institute['id'], public=True, reanswer=True, shuffle_questions=True, # shuffle_answers=True, one_question_at_a_time=True, # create_exam_template=False) # # # Create an create_exam_template to get ID exam_template_id # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create_quiz_template, { # 'exam_id': exam_id, # }) # # # I edited the name and name and theme and description and duration # with open('test_files/image.png', 'rb') as fp1: # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id=response_data['data']['exam_template']['id'], name='test_new', theme='dark', description='test', duration='10:00:00', poster=fp1) # # self.assertEqual( # 'test_new', response_data['data']['exam_template']['name'], error_message) # self.assertEqual( # 'dark', response_data['data']['exam_template']['theme'], error_message) # self.assertEqual( # 'test', response_data['data']['exam_template']['description'], error_message) # self.assertEqual( # '10:00:00', response_data['data']['exam_template']['duration'], error_message) # self.assertIsNotNone( # response_data['data']['exam_template']['poster'], error_message) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id=response_data['data']['exam_template']['id'], name='test_new', theme='dark', description='test', duration='10:00:00', delete_poster=True) # # self.assertEqual( # 'test_new', response_data['data']['exam_template']['name'], error_message) # self.assertEqual( # 'dark', response_data['data']['exam_template']['theme'], error_message) # self.assertEqual( # 'test', response_data['data']['exam_template']['description'], error_message) # self.assertEqual( # '10:00:00', response_data['data']['exam_template']['duration'], error_message) # self.assertIsNone( # response_data['data']['exam_template']['poster'], error_message) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # # exam_template_id deleted is message Forbidden # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id='45bf2004-53ef-43a8-a2c5-473190137fd4', name='test_new', theme='dark', description='test', duration='10:00:00') # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # #exam_template_id is valid # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id='45bf2004-53ef-43a8-a', name='test_new', theme='dark', description='test', duration='10:00:00') # # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id='45bf2004-53ef-43a8-a2c5-473190137fd4', name='#$%', theme='dark', description='test', duration='10:00:00') # # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f: # image = Image.new('RGB', (600, 400), 'red') # image.save(f, 'BMP') # self.image = open(f.name, mode='rb') # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper(exam_template_id='45bf2004-53ef-43a8-a2c5-473190137fd4', # name='test', theme='dark', description='test', duration='10:00:00', override_institute_logo=self.image) # # self.assertEqual(400, status_code, error_message) # self.assertEqual('validation_error', # response_data['status'], error_message) # self.assertEqual('Some fields are not valid', # response_data['message'], error_message) # self.assertEqual('The maximum image side size must be 512 px', # response_data['fields']['override_institute_logo'], error_message) # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.create_quiz_template, { # 'exam_id': exam_id, # }) # # with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f: # image = Image.new('RGB', (100, 100), 'red') # image.save(f, 'BMP') # self.image = open(f.name, mode='rb') # (response_data, status_code, error_message) = self.examHelper.edit_exam_template_helper( # exam_template_id=response_data['data']['exam_template']['id'], name='test', theme='dark', description='test', duration='10:00:00', override_institute_logo=self.image) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_public_get_answer_sheet_error(self): # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_get_answer_sheet, { # 'device_token': device_token, # 'public_id': public_id, # 'question_id': 'invalid', # 'question_index': 0, # 'group_index': 0 # # # # }) # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # def test_public_get_answer_sheet_Successful(self): # # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # exam_page = ExamPage.objects.get(id=exam_page_id) # groups = exam_page.generated_exam['groups'] # # for group in groups: # questions = group['questions'] # group_index = group['index'] # for question in questions: # question_id = question['question_id'] # question_index = question['index'] # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.public_exam_get_answer_sheet, { # 'device_token': device_token, # 'public_id': public_id, # 'question_id': question_id, # 'question_index': question_index, # 'group_index': group_index # # }) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_institute_student_get_answer_sheet_Successful(self): # # exam_page_id, entrance_token, device_token = self.examHelper.finish_an_exam_page_with_answers( # institute_id=self.institute['id'], entrance_type=ENTRANCE_TYPE_API_INVITE) # # exam_page = ExamPage.objects.get(id=exam_page_id) # groups = exam_page.generated_exam['groups'] # # for group in groups: # questions = group['questions'] # group_index = group['index'] # for question in questions: # question_id = question['question_id'] # question_index = question['index'] # (response_data, status_code, error_message) = self.post_without_token(self.examHelper.institute_student_exam_get_answer_sheet, { # 'device_token': device_token, # 'entrance_token': entrance_token, # 'question_id': question_id, # 'question_index': question_index, # 'group_index': group_index # # }) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual( # 'Successful', response_data['message'], error_message) # # def test_institute_student_get_answer_sheet_error(self): # exam_page_id, entrance_token, device_token = self.examHelper.finish_an_exam_page_with_answers( # institute_id=self.institute['id'], entrance_type=ENTRANCE_TYPE_API_INVITE) # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.institute_student_exam_get_answer_sheet, { # 'device_token': device_token, # 'entrance_token': entrance_token, # 'question_id': 'invalid', # 'question_index': 0, # 'group_index': 0 # # # # }) # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # def test_get_exam_page_Successful(self): # exam_page_id, public_id, device_token = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC) # (response_data, status_code, error_message) = self.examHelper.get_exam_page_helper( # exam_page_id=exam_page_id) # # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, len(response_data['data']), error_message) # # def test_get_exam_page_error(self): # # (response_data, status_code, error_message) = self.examHelper.get_exam_page_helper( # exam_page_id='402ebea7-3e10-4c0b-b4e5-3601c1d903b8') # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # (self.non_permitted_user, self.non_permitted_user_token) = self.authenticateHelper.new_user_with_email( # email="non_permitted_user@nisodynamic.com") # # exam_page_id, public_id, device_token = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC) # request = {'exam_page_id': exam_page_id} # # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.exam_page_get, # request, test_token=self.non_permitted_user_token) # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # def test_exam_page_correction_add_Successful(self): # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # (response_data, status_code, error_message) = self.examHelper.correction_add_helper(exam_page_id=exam_page_id, group_index=0, question_index=0, score=2, # comment_for_other_correctors='test', comment_for_student='test') # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, Corrections.objects.filter( # exam_page_id=exam_page_id, group_index=0, question_index=0).count(), error_message) # # ----------------------------------------------------------------------- # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # exam_page = ExamPage.objects.get(id=exam_page_id) # self.assertEqual(EXAM_PAGE_STATE_SCORES_PUBLISHED, # exam_page.state, error_message) # # print(exam_page.state) # (response_data, status_code, error_message) = self.examHelper.correction_add_helper(exam_page_id=exam_page_id, group_index=0, question_index=0, score=2, # comment_for_other_correctors='test', comment_for_student='test') # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, Corrections.objects.filter( # exam_page_id=exam_page_id, group_index=0, question_index=0).count(), error_message) # exam_page = ExamPage.objects.get(id=exam_page_id) # self.assertEqual(EXAM_PAGE_STATE_FINISHED, # exam_page.state, error_message) # # print(exam_page.state) # # ----------------------------------------------------------------------- # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # (response_data, status_code, error_message) = self.examHelper.correction_add_helper( # exam_page_id=exam_page_id, group_index=0, question_index=1, score=2) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(1, Corrections.objects.filter( # exam_page_id=exam_page_id, group_index=0, question_index=1).count(), error_message) # # def test_exam_page_correction_add_error(self): # exam_page_id, public_id, device_token = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC) # (response_data, status_code, error_message) = self.examHelper.correction_add_helper(exam_page_id=exam_page_id, group_index=0, question_index=0, score=2, # comment_for_other_correctors='test', comment_for_student='test') # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # self.assertEqual(0, Corrections.objects.filter( # exam_page_id=exam_page_id, group_index=0, question_index=0).count(), error_message) # # (self.non_permitted_user, self.non_permitted_user_token) = self.authenticateHelper.new_user_with_email( # email="non_permitted_user@nisodynamic.com",) # request = {'exam_page_id': exam_page_id, 'group_index': 0, 'question_index': 0, # 'comment_for_other_correctors': 'test', 'comment_for_student': 'test', 'score': 3} # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.exam_page_correction_add, # request, test_token=self.non_permitted_user_token) # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # def test_exam_page_correction_publish_Successful(self): # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # (response_data, status_code, error_message) = self.examHelper.exam_page_correction_publish_helper( # exam_page_id=exam_page_id) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(['in_progress', 'finished', 'scores_published'], ExamPage.objects.get( # id=exam_page_id).state_history, error_message) # exam_page_id, entrance_token, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_API_INVITE, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # (response_data, status_code, error_message) = self.examHelper.exam_page_correction_publish_helper( # exam_page_id=exam_page_id) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertEqual(['not_attended', 'in_progress', 'finished', 'scores_published'], # ExamPage.objects.get(id=exam_page_id).state_history, error_message) # # def test_exam_page_correction_publish_error(self): # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # (self.non_permitted_user, self.non_permitted_user_token) = self.authenticateHelper.new_user_with_email( # email="non_permitted_user@nisodynamic.com",) # request = {'exam_page_id': exam_page_id} # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.exam_page_correction_publish, # request, test_token=self.non_permitted_user_token) # # self.assertEqual(403, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('Forbidden', response_data['message'], error_message) # # (response_data, status_code, error_message) = self.post_without_token(self.examHelper.exam_page_correction_publish, # request) # # self.assertEqual(401, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual( # 'Access denied', response_data['message'], error_message) # # exam_page_id, public_id, device_token = self.examHelper.enter_exam_helper(self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC) # # (response_data, status_code, error_message) = self.examHelper.exam_page_correction_publish_helper( # exam_page_id=exam_page_id) # self.assertEqual(400, status_code, error_message) # self.assertEqual('error', response_data['status'], error_message) # self.assertEqual('BadRequest', response_data['message'], error_message) # # def test_attended_exam_list_successful(self): # self.examHelper.finish_an_exam_page_with_answers(institute_id=self.institute['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # reanswer=False) # # institute2 = self.instituteHelper.create_institute(name="konkur") # exam_page_id, public_id, device_token = self.examHelper.finish_an_exam_page_with_answers(institute_id=institute2['id'], # entrance_type=ENTRANCE_TYPE_PUBLIC, # shuffle_questions=True, # shuffle_answers=False, # # a name without the letter 'e' # exam_name='lord', # reanswer=False) # # # test without q # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.taken_exam_page_list, { # 'skip': 0, # 'take': 10 # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('pages', response_data['data'], error_message) # self.assertEqual(2, len(response_data['data']['pages']), error_message) # # # test with a q that will resolve to an exam # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.taken_exam_page_list, { # 'skip': 0, # 'take': 10, # # exam name: lord # 'q': 'lo' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('pages', response_data['data'], error_message) # self.assertEqual(1, len(response_data['data']['pages']), error_message) # # # test with a q that resolves to an institute # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.taken_exam_page_list, { # 'skip': 0, # 'take': 10, # # institute name: konkur # 'q': 'konkur' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('pages', response_data['data'], error_message) # self.assertEqual(1, len(response_data['data']['pages']), error_message) # # # test with a q that resolves to an institute and an exam # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.taken_exam_page_list, { # 'skip': 0, # 'take': 10, # # exam name: new_name1 # # institute name: konkur # 'q': 'n' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('pages', response_data['data'], error_message) # self.assertEqual(2, len(response_data['data']['pages']), error_message) # # # test with an available q # (response_data, status_code, error_message) = self.post_with_token(self.examHelper.taken_exam_page_list, { # 'skip': 0, # 'take': 10, # 'q': 'no_exam_or_institute_with_this_name_is_available' # }) # self.assertEqual(200, status_code, error_message) # self.assertEqual('ok', response_data['status'], error_message) # self.assertEqual('Successful', response_data['message'], error_message) # self.assertIn('pages', response_data['data'], error_message) # self.assertEqual(0, len(response_data['data']['pages']), error_message)