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