def test_read_from_disk_transaction_failed(self, add_task_mock):
path = Utils.new_tmp_dir()
self._prepare_contest_dir(path)
Config.statementdir = Utils.new_tmp_dir()
Config.contest_path = path
with self.assertRaises(Exception) as ex:
ContestManager.read_from_disk()
self.assertEqual("ops...", ex.exception.args[0])
self.assertIsNone(Database.get_meta("contest_duration"))
def test_import_contest_removes_file(self):
path = Utils.new_tmp_dir()
self._prepare_contest_dir(path)
Config.statementdir = Utils.new_tmp_dir()
self._write_file(Config.statementdir, "poldo", "foobar")
self.assertTrue(
os.path.isfile(os.path.join(Config.statementdir, "poldo")))
ContestManager.import_contest(path)
self.assertTrue(
os.path.isdir(os.path.join(Config.statementdir, "poldo")))
def test_failed_download_results(self):
Config.storedir = Utils.new_tmp_dir()
wd = os.getcwd()
try:
os.chdir(Config.storedir)
with self.assertRaises(subprocess.CalledProcessError) as ex:
self.admin_handler.download_results(admin_token="ADMIN-TOKEN",
_ip="1.2.3.4")
finally:
os.chdir(wd)
def test_get_absolute_path(self):
backup = Config.storedir
Config.storedir = Utils.new_tmp_dir()
relative_path = 'path/to/file'
abs_path = StorageManager.get_absolute_path(relative_path)
self.assertTrue(abs_path.find(Config.storedir) >= 0)
self.assertTrue(abs_path.find(relative_path) >= 0)
Config.storedir = backup
def test_upload_invalid_pack(self):
enc_path = os.path.join(Utils.new_tmp_dir(), "pack.zip.enc")
Config.encrypted_file = enc_path
Database.del_meta("admin_token")
with self.assertRaises(Forbidden):
self.admin_handler.upload_pack(file={
"content": b"totally not a pack",
"name": "pack.zip.enc"
})
self.assertFalse(os.path.exists(enc_path))
def test_upload_pack_already_uploaded(self):
path = os.path.join(Utils.new_tmp_dir(), "pack.zip.enc")
with open(path, "wb") as f:
f.write(b"hola!")
Config.encrypted_file = path
Database.del_meta("admin_token")
with self.assertRaises(Forbidden):
self.admin_handler.upload_pack(file={
"content": "foobar".encode(),
"name": "pack.zip.enc"
})
def test_download_results(self):
Config.storedir = Utils.new_tmp_dir()
wd = os.getcwd()
try:
os.chdir(Config.storedir)
with open("db.sqlite3_for_test", "w") as f:
pass
zip_location = self.admin_handler.download_results(
admin_token="ADMIN-TOKEN", _ip="1.2.3.4")["path"]
with open(os.path.join(Config.storedir, zip_location)) as f:
pass
finally:
os.chdir(wd)
def test_download_results(self):
Config.storedir = Utils.new_tmp_dir()
wd = os.getcwd()
try:
os.chdir(Config.storedir)
with open('db.sqlite3_for_test', 'w') as f:
pass
zip_location = self.admin_handler.download_results(
admin_token='ADMIN-TOKEN', _ip='1.2.3.4')['path']
with open(os.path.join(Config.storedir, zip_location)) as f:
pass
finally:
os.chdir(wd)
def test_extract_bad_zip(self):
self.tempdir = Utils.new_tmp_dir()
enc_path = os.path.join(self.tempdir, "pack.zip.enc")
dec_path = os.path.join(self.tempdir, "pack.zip")
Config.encrypted_file = enc_path
Config.decrypted_file = dec_path
with open(enc_path, "wb") as f:
invalid_zip = b"this is not a zip"
encrypted = crypto.encode(b"fooobar", invalid_zip, b"metadata")
f.write(encrypted)
password = crypto.gen_user_password("XXXXXX", b"YYY", b"fooobar")
with self.assertRaises(Forbidden) as e:
ContestManager.extract_contest(password)
def test_import_contest(self):
path = Utils.new_tmp_dir()
self._prepare_contest_dir(path)
Config.statementdir = Utils.new_tmp_dir()
os.makedirs(os.path.join(Config.statementdir, "poldo"))
contest = ContestManager.import_contest(path)
self.assertTrue(
os.path.isfile(
os.path.join(Config.statementdir, "poldo", "statement.md")))
self.assertEqual(18000, contest["duration"])
self.assertEqual(1, len(contest["tasks"]))
task = contest["tasks"][0]
self.assertEqual("poldo", task["name"])
self.assertEqual("Poldo", task["description"])
self.assertEqual(42, task["max_score"])
checker = os.path.join(path, "poldo", "managers",
"checker.linux.x86_64")
validator = os.path.join(path, "poldo", "managers",
"validator.linux.x86_64")
generator = os.path.join(path, "poldo", "managers",
"generator.linux.x86_64")
self.assertEqual(checker, task["checker"])
self.assertEqual(validator, task["validator"])
self.assertEqual(generator, task["generator"])
self.assertEqual(
os.path.join(Config.web_statementdir, "poldo", "statement.md"),
task["statement_path"],
)
self.assertEqual(0o755, os.stat(checker).st_mode & 0o777)
self.assertEqual(0o755, os.stat(validator).st_mode & 0o777)
self.assertEqual(0o755, os.stat(generator).st_mode & 0o777)
self.assertEqual(1, len(contest["users"]))
user = contest["users"][0]
self.assertEqual("token", user["token"])
self.assertEqual("Test", user["name"])
self.assertEqual("User", user["surname"])
def test_rename_file(self):
backup = Config.storedir
Config.storedir = Utils.new_tmp_dir()
relative_path = 'baz/file.txt'
new_path = 'baz/txt.elif'
StorageManager.save_file(relative_path, 'foobar'.encode())
StorageManager.rename_file(relative_path, new_path)
with open(StorageManager.get_absolute_path(new_path), 'r') as file:
lines = file.readlines()
self.assertEqual('foobar', lines[0])
Config.storedir = backup
def test_read_from_disk(self):
path = Utils.new_tmp_dir()
self._prepare_contest_dir(path)
Config.statementdir = Utils.new_tmp_dir()
Config.contest_path = path
with patch("gevent.spawn") as mock:
ContestManager.read_from_disk()
mock.assert_has_calls(
[call(ContestManager.worker, "poldo")], any_order=True)
self.assertEqual(18000, Database.get_meta(
"contest_duration", type=int))
tasks = Database.get_tasks()
self.assertEqual(1, len(tasks))
self.assertEqual("poldo", tasks[0]["name"])
self.assertEqual("Poldo", tasks[0]["title"])
self.assertEqual(42, tasks[0]["max_score"])
self.assertEqual(0, tasks[0]["num"])
users = Database.get_users()
self.assertEqual(1, len(users))
self.assertEqual("token", users[0]["token"])
self.assertEqual("Test", users[0]["name"])
self.assertEqual("User", users[0]["surname"])
self.assertEqual(0, users[0]["extra_time"])
user_tasks = Database.get_user_task("token", "poldo")
self.assertEqual("token", user_tasks["token"])
self.assertEqual("poldo", user_tasks["task"])
self.assertEqual(0, user_tasks["score"])
self.assertIsNone(user_tasks["current_attempt"])
self.assertTrue(Database.get_meta("contest_imported", type=bool))
self.assertTrue(ContestManager.has_contest)
self.assertIn("poldo", ContestManager.tasks)
self.assertIn("poldo", ContestManager.input_queue)
def test_save_file(self):
backup = Config.storedir
Config.storedir = Utils.new_tmp_dir("new_path")
relative_path = os.path.join("baz", "file.txt")
content = 'This is the content of the file'
try:
os.remove(Config.storedir)
except:
pass
StorageManager.save_file(relative_path, content.encode())
with open(StorageManager.get_absolute_path(relative_path),
'r') as file:
file_content = file.readlines()
self.assertEqual(1, len(file_content))
self.assertEqual(content, file_content[0])
Config.storedir = backup
