async def test_submit_2(self): """ course-homework submit multi-worker check ratio lock :return: """ print_test('test_submit_2:') uri = self.url + '/submit' cur_user = self.user_st1 tar_problem = self.problem_1_ta1 tar_homework = self.homework_submitable request_param = { 'user_id': cur_user['id'], 'problem_id': tar_problem['id'], 'homework_id': tar_homework['id'], 'record_type': RecordTypes.TEST, 'src_code': 'hello,world', 'src_language': Languages.CPP, 'test_ratio': 3, } await gen.multi([ self.submit_worker(uri, cur_user, request_param, SIClient(), 0), self.submit_worker(uri, cur_user, request_param, SIClient(), 1), self.submit_worker(uri, cur_user, request_param, SIClient(), 2), ]) records = await self.recordTable.getObject(**request_param) self.assertEqual(tar_problem['ratio_three_limit'], len(records))
async def test_login(self): print_test('test: login. ') uri = self.url + '/login' # fail: user do not exist response = self.getbodyObject(await self.post_request(uri, username='******', password='******')) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 1) # fail: incorrect password response = self.getbodyObject(await self.post_request(uri, username='******', password='******')) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 1) # success response = self.getbodyObject(await self.post_request(uri, username='******', password='******')) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 0) dbobj = (await self.db.getObject('users', username='******'))[0] self.assertEqual(response['id'], dbobj.id) self.assertEqual(response['role'], dbobj.role) # TODO: can one login in if he's already online? pass
async def test_submit_3(self): """ course-homework submit multi-worker check judgestates lock :return: """ print_test('test_submit_3:') uri = self.url + '/submit' cur_user = self.user_st1 tar_problem = self.problem_1_ta1 tar_homework = self.homework_submitable request_param = { # 'user_id': None, 'problem_id': tar_problem['id'], 'homework_id': tar_homework['id'], 'record_type': RecordTypes.SUBMIT, 'src_code': 'hello,world', 'src_language': Languages.CPP, } await gen.multi([ self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 0), self.submit_worker(uri, self.user_st2, deepcopy(request_param), SIClient(), 1), # self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 5), ]) judgestate_after_post = await self.db.getObject( 'judgestates', homework_id=tar_homework['id'], problem_id=tar_problem['id']) self.assertIsInstance(judgestate_after_post, list) self.assertEqual(1, len(judgestate_after_post)) judgestate_after_post = judgestate_after_post[0] print_test('submit3-judgestates: ', judgestate_after_post) self.assertEqual(2, judgestate_after_post['total'])
def get_app(self): print_test('call get_app') return Application(None, self.root_dir, options.RoutineList, **options.AppConfig, )
async def test_example(self): print_test('example_test') # TODO: no way to test condition # await gen.multi([self.try_to_dosth_in_db1(), self.try_to_dosth_in_db2()]) # operating db # first request # self.io_loop.spawn_callback(self.try_to_dosth_in_db1) # self.io_loop.spawn_callback(self.try_to_dosth_in_db2) # await self.i response = await self.get_response( '/api/user/query', method='POST', body='{ "username" : "hfzzz"}' ) self.assertIn(b'hfzzz', response.body) # second request response = await self.post_request('/api/user/query', username = '******', password = '******') self.assertIn(b'"username": "******"', response.body) # third request response = await self.post_request('/api/user/query', username = '******') response_object = self.getbodyObject(response) self.assertEqual(response_object[0]['username'], 'hfzzz') # query db print_test('getobj in db: ', await self.db.getObject('users', username='******'))
async def test_delete(self): uri = self.url + '/delete' # ta = await self.db.getObjectOne('users', username='******') # student = await self.db.getObjectOne('users', username='******') ta = self.ta1_zjl student = self.student1_hfz course = await self.db.getObjectOne('courses', name='泽学') homework = await self.db.createObject( 'homeworks', name='hello world', description='not necessary', deadline=datetime.datetime.fromtimestamp(10000), problems=[1], course_id=course['id']) course['homeworks'].append(homework['id']) await self.db.saveObject('courses', object=course) # fail -student delete homwork await self.login_object(student) response = self.getbodyObject(await self.post_request(uri, id=homework['id'])) self.assertEqual(response['code'], 1) self.logout_object(student) # pass print_test('zjl_role', ta['role']) await self.login_object(ta) response = self.getbodyObject(await self.post_request(uri, id=homework['id'])) self.assertEqual(response['code'], 0) course = await self.db.getObjectOne('courses', name='泽学') self.assertNotIn(homework['id'], course['homeworks'])
async def test_lock2(self): await gen.multi([ self.use_judgestates(self.db, 1), self.use_judgestates(self.db, 2) ]) obj = await self.db.getObjectOne('judgestates', id=1) print_test('after op: ', obj) self.assertEqual(obj['judged'], 1)
async def test_submit_1(self): """ course-homework submit :return: """ print_test('test_submit_0:') uri = self.url + '/submit' cur_user = self.user_st1 tar_problem = self.problem_1_ta1 tar_homework = self.homework_submitable await self.login_object(cur_user) for k in range(tar_problem['ratio_one_limit']): request_param = { 'user_id': cur_user['id'], 'problem_id': tar_problem['id'], 'homework_id': tar_homework['id'], 'record_type': RecordTypes.TEST, 'src_code': 'hello,world', 'src_language': Languages.CPP, 'test_ratio': 1, } response = await self.post_request_return_object( uri, **request_param) self.assertEqual(0, response['code']) ratio_after_post = await self.db.getObject( 'ratios', homwork_id=tar_homework['id'], problem_id=tar_problem['id'], user_id=cur_user['id']) self.assertIsInstance(ratio_after_post, list) self.assertEqual(1, len(ratio_after_post)) ratio_after_post = ratio_after_post[0] self.assertEqual(k + 1, ratio_after_post['ratio_one_used']) request_param = { 'user_id': cur_user['id'], 'problem_id': tar_problem['id'], 'homework_id': tar_homework['id'], 'record_type': RecordTypes.TEST, 'src_code': 'hello,world', 'src_language': Languages.CPP, 'test_ratio': 1, } response = await self.post_request_return_object(uri, **request_param) self.assertEqual(1, response['code']) ratio_after_post = await self.db.getObject( 'ratios', homwork_id=tar_homework['id'], problem_id=tar_problem['id'], user_id=cur_user['id']) self.assertIsInstance(ratio_after_post, list) self.assertEqual(1, len(ratio_after_post)) ratio_after_post = ratio_after_post[0] self.assertEqual(tar_problem['ratio_one_limit'], ratio_after_post['ratio_one_used']) records = await self.recordTable.getObject(**request_param) self.assertEqual(tar_problem['ratio_one_limit'], len(records))
def setUp(self): self.admin_pass = '******' self.root_dir = 'test_root/' options.parse_config_file('./settings/app_test_config.py') if (not os.getenv('USE_TRAVIS', None)): options.parse_config_file('./settings/env_config.py') else: options.parse_command_line('./settings/env_config_example.py') print_test('travis: parse env config example') print_test('parse env config, Appconfig = ', options.AppConfig) self.db = None self.cookies = dict() self.user_id_cookie = '' super(BaseTestCase, self).setUp()
async def test_query_ratio(self): response = self.getbodyObject(await self.post_request('/api/user/login', username='******', password='******')) self.assertEqual(response['code'], 0) ratio_response = self.getbodyObject(await self.post_request( self.url + '/query', homework_id=1, problem_id=1, user_id=self.user1['id'])) print_test(ratio_response) self.assertEqual(len(ratio_response), 1) self.assertEqual(ratio_response[0]['ratio_one_used'], 10)
async def test_modifypwd(self): # response = await self.post_request_return_object('/api/ratio/list', start = 1, end = 2) # print('test list: ', response) print_test('test_modifypwd') uri = self.url + '/modifypwd' # not log in response = await self.post_request_return_object( uri, id=self.user_st['id'], old_pwd=self.user_st['password'], new_pwd='hfztttql') self.assertEqual(1, response['code']) # modify success await self.login_object(self.user_ta) modify_options = { 'old_pwd': self.user_ta['password'], 'new_pwd': 'hfzttttql' } response = await self.post_request_return_object(uri, id=self.user_ta['id'], **modify_options) self.assertEqual(0, response['code']) modified = await self.db.getObjectOne('users', id=self.user_ta['id']) self.assertEqual(modified['password'], get_md5(modify_options['new_pwd'])) # modify failed modify_options = {'old_pwd': 'wrongpass', 'new_pwd': 'failed'} response = await self.post_request_return_object(uri, id=self.user_ta['id'], **modify_options) self.assertEqual(1, response['code']) modified_2 = await self.db.getObjectOne('users', id=self.user_ta['id']) self.assertNotEqual(modified['password'], get_md5(modified_2['password'])) #modify other modify_options = { 'old_pwd': self.user_st['password'], 'new_pwd': 'failed' } response = await self.post_request_return_object(uri, id=self.user_st['id'], **modify_options) modified_3 = await self.db.getObjectOne('users', id=self.user_st['id']) self.assertEqual(1, response['code']) self.assertNotEqual(self.user_st['password'], get_md5(modified_3['password']))
async def test_submit_4(self): """ course-homework submit multi-worker check only one final submit record :return: """ print_test('test_submit_4:') uri = self.url + '/submit' cur_user = self.user_st1 tar_problem = self.problem_1_ta1 tar_homework = self.homework_submitable request_param = { # 'user_id': None, 'problem_id': tar_problem['id'], 'homework_id': tar_homework['id'], 'record_type': RecordTypes.SUBMIT, 'src_code': 'hello,world', 'src_language': Languages.CPP, } await gen.multi([ self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 0), self.submit_worker(uri, self.user_st2, deepcopy(request_param), SIClient(), 1), self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 4), self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 5), ]) await gen.multi([ self.submit_worker(uri, self.user_st1, deepcopy(request_param), SIClient(), 3), ]) records = await self.recordTable.getObject(**request_param) self.assertIsInstance(records, list) self.assertEqual(2, len(records)) for record in records: # response = await self.post_request_return_object(self.returnresult_url, # id=record['id'], # res={ # 'Result': 'Accept', # 'time': 12, # 'memory': 123, # 'Info': 'ok', # }, # secret=options.judgerSecret) # self.assertEqual(0, response['code']) print_test('submit4-records', record)
async def test_delete(self): print_test('test: delete. ') uri = self.url + '/delete' # no permission await self.login_object(self.user_ta) respons = await self.post_request_return_object(uri, id=self.user_st['id']) self.assertEqual(1, respons['code']) user_st_query_result = await self.db.getObject('users', id=self.user_st['id']) self.assertIsInstance(user_st_query_result, list) self.assertEqual(1, len(user_st_query_result)) # success await self.login_object(self.user_admin) respons = await self.post_request_return_object(uri, id=self.user_st['id']) self.assertEqual(0, respons['code']) user_st_query_result = await self.db.getObject('users', id=self.user_st['id']) self.assertEqual(0, len(user_st_query_result))
async def use_judgestates(self, db, id): print_test('use_judgestates: ', id) async with db.get_lock_object('judgestates', id): obj = await db.getObjectOne('judgestates', id=id) obj['judged'] += 1 print_test('use_judgestates get : ', id, obj) await db.saveObject('judgestates', obj) print_test('use_judgestates done: ', id)
async def test_logout(self): uri = self.url + '/logout' print_test('test: logout. ') # fail: user do not exist response = self.getbodyObject(await self.post_request(uri, id=100)) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 1) # print_test('xxxx') # fail: absent of id field response = self.getbodyObject(await self.post_request(uri)) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 1) # fail: not logged in hfzobj = (await self.db.getObject('users', username='******'))[0] response = self.getbodyObject(await self.post_request(uri, id=hfzobj.id)) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 1) # success # login first response = self.getbodyObject(await self.post_request(self.url + '/login', username='******', password='******')) self.assertIsInstance(response, dict) self.assertEqual(response['code'], 0) user_id = response['id'] response = self.getbodyObject(await self.post_request(uri, id=response['id'])) self.assertEqual(0, response['code']) response = self.getbodyObject(await self.post_request(uri, id=user_id)) self.assertEqual(1, response['code'])
def setUp(self): super().setUp() print_test('try_to run fake judger') if (not os.getenv('USE_TRAVIS', None)): print_test('local-fake-judger') self.fakejudge = subprocess.Popen( ['./venv/bin/python', 'fake_judger.py']) else: print_test('travis: do not need-fake-judger')
async def submit_worker(self, uri, cur_user, request_param, client, worker_id): print_test('submit_wokder:', worker_id) request_param['user_id'] = cur_user['id'] await self.login_object(cur_user, client=client) print_test('submit_woker-user = '******'id'], client.user_id_cookie, request_param['user_id']) response = await self.post_request_return_object(uri, **request_param, client=client) print_test('submit worker get response: ', response)
async def set_application_db(self): print_test('in get_db', options.db_host, options.db_port, options.db_user, options.db_password, options.db_database) while True: try: db = await aiopg.create_pool( host=options.db_host, port=options.db_port, user=options.db_user, password=options.db_password, dbname=options.db_database) await re_create_tables(db, './sql/schema.sql') print_test('create pool done') break except: print_test("retrying to connect test database") pass rdb = BaseDB(db) self.db = rdb self._app.setDB(rdb) print_test('get_db done')
async def test_submit_0(self): """ public submit :return: """ print_test('test_submit_0:') uri = self.url + '/submit' cur_user = self.user_st1 tar_problem = self.problem_0_ta1 await self.login_object(cur_user) request_param = { 'user_id': cur_user['id'], 'problem_id': tar_problem['id'], 'record_type': RecordTypes.PUBLIC, 'src_code': 'hello,world', 'src_language': Languages.CPP, 'test_ratio': 3, } response = await self.post_request_return_object(uri, **request_param) self.assertEqual(0, response['code']) record_after_post = await self.recordTable.getObject(**request_param) self.assertIsInstance(record_after_post, list) self.assertEqual(1, len(record_after_post)) record_after_post = record_after_post[0] response = await self.post_request_return_object( self.returnresult_url, id=record_after_post['id'], res={ 'Result': 'Accept', 'time': 12, 'memory': 123, 'Info': 'ok', }, secret=options.judgerSecret) record_after_judge = await self.recordTable.getObjectOne( id=record_after_post['id']) print_test('record after judge: ', record_after_judge) print_test('len ratio table:', len(await self.db.all('ratios')))
async def test_judgerinfo(self): info = {'Info': 'you are good'} uri = self.url+'/judgerInfo' # admin = await self.db.getObjectOne('users', username='******') # ta = await self.db.getObjectOne('users', username='******') # student = await self.db.getObjectOne('users', username='******') # student2 = await self.db.getObjectOne('users', username='******') admin = self.admin ta = self.ta1 student = self.student1 student2 = self.student2 record1 = await self.db.createObject('records', record_type=2, user_id=student['id'], problem_id=1, homework_id=2, time_consume=500, score=100, result=0) path = '{}/{root_dir}/records/{}'.format(os.getcwd(), record1['id'], root_dir = self.root_dir) info_path = '{}/{}.json'.format(path, record1['id']) if not os.path.exists(path): os.makedirs(path) info_file = open(info_path, 'w') json.dump(info, info_file) info_file.close() # fail student check info of closed homework await self.login_object(student) response = self.getbodyObject(await self.post_request(uri, record_id=record1['id'])) self.assertEqual(1, response['code']) # pass ta check info of closed homework await self.login_object(ta) response = self.getbodyObject(await self.post_request(uri, record_id=record1['id'])) self.assertEqual('you are good', response['info']) # pass admin check await self.login_object(admin) response = self.getbodyObject(await self.post_request(uri, record_id=record1['id'])) self.assertEqual('you are good', response['info']) shutil.rmtree(path) record2 = await self.db.createObject('records', record_type=2, user_id=student['id'], problem_id=1, homework_id=1, score=100) path = '{}/{root_dir}/records/{}'.format(os.getcwd(), record2['id'], root_dir = self.root_dir) info_path = '{}/{}.json'.format(path, record2['id']) if not os.path.exists(path): os.makedirs(path) info_file = open(info_path, 'w') json.dump(info, info_file) info_file.close() # fail student check info not belonging to him await self.login_object(student2) response = self.getbodyObject(await self.post_request(uri, record_id=record2['id'])) self.assertEqual(1, response['code']) # pass student check his own open info await self.login_object(student) response = self.getbodyObject(await self.post_request(uri, record_id=record2['id'])) self.assertEqual('you are good', response['info']) shutil.rmtree(path) record3 = await self.db.createObject('records', record_type=1, user_id=student2['id'], homework_id=3, problem_id=1, test_ratio=2, result_type=0 ) path = '{}/{root_dir}/records/{}'.format(os.getcwd(), record3['id'], root_dir = self.root_dir) print_test('recordtest: ', path) info_path = '{}/{}.json'.format(path, record3['id']) if not os.path.exists(path): os.makedirs(path) info_file = open(info_path, 'w') json.dump(info, info_file) info_file.close() # fail ta check info not in his course await self.login_object(ta) response = self.getbodyObject(await self.post_request(uri, record_id=record3['id'])) self.assertEqual(1, response['code']) shutil.rmtree(path)
async def try_createObject(self): print_test('try_createObj') await self.db.createObject('users', username='******', password='******', email='dd') print_test('create: ', await self.db.getObject('users', username = '******'))
async def test_update_3(self): """ test: post with code_uri, should rejudge, update problem_status :return: """ print_test('test_update_3') uri = self.url + '/update' await self.login_object(self.user_ta1) tar_problem = self.problem_0_ta1 # copy std_correct to path_src = '''{dir}{file_name}'''.format( dir=self.problem0_io['dir'], file_name=self.problem0_io['std_wrong']) std_wrong_filename = str(uuid.uuid1()) + '.code' path_tar = '''{dir}{file_name}'''.format(dir=self.tmp_dir, file_name=std_wrong_filename) shutil.copyfile(path_src, path_tar) # copy data to path_src = '''{dir}{file_name}'''.format( dir=self.problem0_io['dir'], file_name=self.problem0_io['data_zip']) data_filename = str(uuid.uuid1()) + '.zip' path_tar = '''{dir}{file_name}'''.format(dir=self.tmp_dir, file_name=data_filename) shutil.copyfile(path_src, path_tar) modify_param = { 'id': tar_problem['id'], 'title': str(uuid.uuid1()), 'description': 'dl3431324few', 'time_limit': 1108, 'memory_limit': 123456, 'code_uri': 'tmp/' + std_wrong_filename, } response = await self.post_request_return_object(uri, **modify_param) self.assertEqual(0, response['code']) problem_after_post = await self.problemTable.getObject( id=tar_problem['id']) self.assertIsInstance(problem_after_post, list) self.assertEqual(1, len(problem_after_post)) problem_after_post = problem_after_post[0] self.assertEqual(modify_param['time_limit'], problem_after_post['time_limit']) self.assertEqual(modify_param['title'], problem_after_post['title']) tar_record = await self.recordTable.getObject( problem_id=tar_problem['id'], record_type=RecordTypes.STD) self.assertIsInstance(tar_record, list) self.assertEqual(1, len(tar_record)) tar_record = tar_record[0] response = await self.post_request_return_object( self.returnresult_url, id=tar_record['id'], res={ 'Result': 'Wrong Answer', 'time': 12, 'memory': 123, 'Info': 'ok', }, secret=options.judgerSecret) problem_after_judge = await self.problemTable.getObject( id=tar_problem['id']) self.assertIsInstance(problem_after_judge, list) self.assertEqual(1, len(problem_after_judge)) problem_after_judge = problem_after_judge[0] self.assertEqual(0, problem_after_judge['status'])