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'])
