def test_del_meta(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta('random_key', 4242)
self.assertTrue(Database.del_meta('random_key'))
self.assertIsNone(Database.get_meta('random_key'))
def test_get_meta_default(self):
Database.connected = False
Database.connect_to_database()
meta = Database.get_meta('this_key_doesnt_exist',
'default_value_is_cool')
self.assertEqual('default_value_is_cool', meta)
def test_set_meta(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta('random_key', 42)
value = Database.get_meta('random_key', type=int)
self.assertEqual(42, value)
def prepare_test(load_config=True, connect_database=True,
connect_logger=True):
config_file_name = Utils.new_tmp_file()
log_file_name = Utils.new_tmp_file()
db_file_name = Utils.new_tmp_file()
contest_dir = Utils.new_tmp_dir("contest", create=False)
with open(config_file_name, 'w') as file:
file.write("logfile: %s\n"
"db: %s\n"
"storedir: %s\n"
"contest_path: %s\n" % (log_file_name, db_file_name,
Utils.new_tmp_dir(),
contest_dir))
if load_config:
Config.loaded = False
Config.set_config_file(config_file_name)
if connect_logger:
Logger.connected = False
Logger.connect_to_database()
Logger.set_log_level("WARNING")
if connect_database:
Database.connected = False
Database.connect_to_database()
def test_get_meta_default(self):
Database.connected = False
Database.connect_to_database()
meta = Database.get_meta("this_key_doesnt_exist",
"default_value_is_cool")
self.assertEqual("default_value_is_cool", meta)
def test_set_meta_overwrite(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta("random_key", 4242)
Database.set_meta("random_key", 42)
value = Database.get_meta("random_key", type=int)
self.assertEqual(42, value)
def test_get_meta_type_bool(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta('boooool', True)
self.assertTrue(Database.get_meta('boooool', type=bool))
Database.set_meta('boooool2', False)
self.assertFalse(Database.get_meta('boooool2', type=bool))
def test_transaction_commit(self):
Database.connected = False
Database.connect_to_database()
Database.begin()
Database.set_meta('random_foobar', 123, autocommit=False)
Database.commit()
self.assertEqual(123, Database.get_meta('random_foobar', type=int))
def test_input_invalid_params(self):
Database.connected = False
Database.connect_to_database()
with self.assertRaises(ValueError) as ex:
Database.get_input()
self.assertEqual("Invalid parameters to get_input",
ex.exception.args[0])
def test_get_meta_none(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta("test", None)
Database.set_meta("test2", "None")
self.assertEqual(Database.get_meta("test"), None)
self.assertEqual(Database.get_meta("test", type=int), None)
self.assertEqual(Database.get_meta("test", None, type=int), None)
self.assertEqual(Database.get_meta("test2", None), "None")
def test_dictify(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta('random_key', 'random_value')
Database.c.execute("SELECT * FROM metadata WHERE key = 'random_key'")
dct = Database.dictify(all=False)
self.assertDictEqual({'key': 'random_key', 'value': 'random_value'},
dct)
def test_transaction_rollback(self):
Database.connected = False
Database.connect_to_database()
Database.begin()
Database.set_meta('random_foobar', 123, autocommit=False)
Database.rollback()
self.assertEqual(42, Database.get_meta('random_foobar', default=42,
type=int))
def test_dictify(self):
Database.connected = False
Database.connect_to_database()
Database.set_meta("random_key", "random_value")
Database.c.execute("SELECT * FROM metadata WHERE key = 'random_key'")
dct = Database.dictify(all=False)
self.assertDictEqual({
"key": "random_key",
"value": "random_value"
}, dct)
def test_do_write_rollback(self):
Database.connected = False
Database.connect_to_database()
with patch("terry.database.Database.commit",
side_effect=ValueError("Ops...")):
with self.assertRaises(ValueError):
Database.do_write(True, """
INSERT INTO metadata (key, value)
VALUES (:key, :value)
""", {"key": "ciao", "value": "mondo"})
self.assertIsNone(Database.get_meta("ciao"))
def test_dictify_all(self):
Database.connected = False
Database.connect_to_database()
Database.c.execute("DELETE FROM metadata")
Database.c.execute(
"INSERT INTO metadata (key, value) VALUES ('foo1', 'bar')")
Database.c.execute(
"INSERT INTO metadata (key, value) VALUES ('foo2', 'bar')")
Database.c.execute("SELECT * FROM metadata")
lst = Database.dictify(all=True)
self.assertIsInstance(lst, list)
self.assertEqual(2, len(lst))
def extract_and_connect(path, workdir):
from terry.config import Config
from terry.database import Database
from terry.logger import Logger
with zipfile.ZipFile(path) as f:
f.extractall(workdir)
db_path = os.path.join(workdir, "db.sqlite3")
log_path = os.path.join(workdir, "log.sqlite3")
Config.db = db_path
Config.logfile = log_path
Database.connect_to_database()
Logger.connect_to_database()
try:
yield
finally:
Database.disconnect_database()
Logger.disconnect_database()
def drop_contest(self, admin_token):
"""
POST /admin/drop_contest
"""
if not os.path.exists(Config.encrypted_file):
self.raise_exc(NotFound, "NOT_FOUND", "No packs found")
Logger.warning("DROP_CONTEST", "Started dropping contest")
with open(Config.encrypted_file, "rb") as f:
pack = f.read()
db_token = Database.get_meta("admin_token")
# contest has been extracted but the token is wrong
if db_token is not None and db_token != admin_token:
self.raise_exc(Forbidden, "FORBIDDEN", "Wrong token")
# contest has not been extracted
if db_token is None:
try:
password = crypto.recover_file_password_from_token(admin_token)
crypto.decode(password, pack)
except nacl.exceptions.CryptoError:
# pack password is wrong
self.raise_exc(Forbidden, "FORBIDDEN", "Wrong pack token")
metadata = ruamel.yaml.safe_load(crypto.metadata(pack).strip(b"\x00"))
if not metadata.get("deletable"):
self.raise_exc(Forbidden, "FORBIDDEN", "Contest not deletable")
shutil.rmtree(Config.storedir, ignore_errors=True)
shutil.rmtree(Config.statementdir, ignore_errors=True)
shutil.rmtree(Config.contest_path, ignore_errors=True)
for f in (Config.encrypted_file, Config.decrypted_file):
try:
os.remove(f)
except FileNotFoundError:
pass
Database.disconnect_database()
for f in glob.glob(Config.db + "*"):
os.remove(f)
Database.connect_to_database()
Logger.warning("DROP_CONTEST", "Contest dropped")
return {}
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c",
"--config",
help="Path to the config file",
default="config/config.yaml")
args = parser.parse_args()
if args.config:
Config.set_config_file(args.config)
Logger.set_log_level(Config.log_level)
Logger.connect_to_database()
Database.connect_to_database()
try:
ContestManager.read_from_disk(remove_enc=False)
except:
Logger.warning("CONTEST", "Failed to read the contest from disk...")
server = Server()
server.run()
def test_database_upgrade(self):
backup = Schema.UPDATERS
Schema.UPDATERS = [
'CREATE TABLE metadata (key TEXT PRIMARY KEY, value TEXT);',
# this table is needed
'CREATE TABLE dummy_test (foo INTEGER);',
'INSERT INTO dummy_test VALUES(42);'
]
Database.connected = False
Database.connect_to_database()
Database.c.execute("SELECT * FROM dummy_test")
row = Database.c.fetchone()
self.assertEqual(42, row[0])
Database.c.execute(
"SELECT * FROM metadata WHERE key = 'schema_version'")
row = Database.c.fetchone()
self.assertEqual(len(Schema.UPDATERS) - 1, int(row[1]))
Schema.UPDATERS = backup
def test_get_meta_type(self):
Database.connected = False
Database.connect_to_database()
schema_version = Database.get_meta('schema_version', type=int)
self.assertIsInstance(schema_version, int)
def test_get_meta_default_type(self):
Database.connected = False
Database.connect_to_database()
meta = Database.get_meta('not_existing_key', '42', type=int)
self.assertIsInstance(meta, str)
def test_get_meta(self):
Database.connected = False
Database.connect_to_database()
schema_version = int(Database.get_meta('schema_version'))
self.assertEqual(len(Schema.UPDATERS) - 1, schema_version)
def test_invalid_database_path(self):
Config.db = '/path/that/not/exists'
Database.connected = False
with self.assertRaises(Exception):
Database.connect_to_database()
def test_missing_db(self):
db_path = Utils.new_tmp_file()
os.remove(db_path)
Config.db = db_path
Database.connected = False
Database.connect_to_database()
def test_double_connect_to_database(self):
Database.connected = False
Database.connect_to_database()
with self.assertRaises(RuntimeError) as ex:
Database.connect_to_database()
self.assertEqual("Database already loaded", ex.exception.args[0])
def test_connect_to_database(self):
Database.connected = False
Database.connect_to_database()
def test_get_meta_without_default(self):
Database.connected = False
Database.connect_to_database()
meta = Database.get_meta('not_existing_key')
self.assertIsNone(meta)
def test_get_meta_type_without_default(self):
Database.connected = False
Database.connect_to_database()
self.assertIsNone(Database.get_meta('not_existing_key', type=int))
def test_del_meta_non_exist(self):
Database.connected = False
Database.connect_to_database()
self.assertFalse(Database.del_meta('random_key'))
self.assertIsNone(Database.get_meta('random_key'))
