def test_015_connections(self):
"""HistoriaDatabase: Connect and then Disconnect"""
db = core_data_objects.HistoriaDatabase(None)
db.connection_settings = self.default_settings
db.connect()
self.assertTrue(
db.connected,
"database object not reporting being connected after connect")
db.disconnect()
self.assertIsNotNone(
db.connection,
"Connection is none after disconnecting (there should still be an object kicking around)"
)
self.assertFalse(
db.connected,
"database object reporting being connected after connect")
self.assertFalse(
db.connection.is_connected(),
"Connection object is not reporting being connected (which means you have two problems most likely)"
)
self.assertEqual(db.connected, db.connection.is_connected(),
"Someone is lying about the connection status.")
def prep_execute_test_tables(self):
db = core_data_objects.HistoriaDatabase(self.testdb_name)
statements = db.generate_database_SQL()
db.connection_settings = self.default_settings
db.connect()
cur = db.cursor()
self.test_table = "test"
# Convert to list for editing
statements = list(statements)
statements += (('USE `{0}`'.format(self.testdb_name), {}), )
statements += ((
"CREATE TABLE `{0}` (`id` int(11) unsigned NOT NULL AUTO_INCREMENT,`val` varchar(128) NOT NULL DEFAULT '',PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;"
.format(self.test_table), {}), )
for state in statements:
try:
cur.execute(state[0], state[1])
db.commit()
except mysql.connector.Error as err:
print(
"Unable to create testing database and required tables: {0} \n while executing: {1}"
.format(err, state[0]),
file=sys.stderr)
return False
return db
def setUp(self):
self.config = TestSearchObject.config
self.testdb_name = self.config['database']["main_database"]
self.default_settings = {
'user': self.config['database']['user'],
'password': self.config['database']['password'],
'host': self.config['database']['host'],
'database': '',
'raise_on_warnings': self.config['database']["raise_on_warnings"]
}
self.db = core_data_objects.HistoriaDatabase(self.testdb_name)
def tearDown(self):
# Make a good faith effort to clean up any database we created along the way.
try:
db = core_data_objects.HistoriaDatabase(None)
db.connection_settings = self.default_settings
db.connect()
cur = db.cursor()
cur.execute("DROP DATABASE `{0}`".format(self.testdb_name))
db.commit()
db.disconnect()
except Exception as err:
pass
def test_020_cursors(self):
"""HistoriaDatabase: Get Cursor"""
db = core_data_objects.HistoriaDatabase(None)
db.connection_settings = self.default_settings
db.connect()
cur = db.cursor()
self.assertIsNotNone(cur, "Cursor came back as none.")
self.assertIsInstance(cur, mysql.connector.cursor.MySQLCursorDict,
"Cursor is the wrong type: %s" % cur)
def test_030_generateDBSQL(self):
"""HistoriaDatabase: generate SQL for database"""
db = core_data_objects.HistoriaDatabase(self.testdb_name)
statements = db.generate_database_SQL()
self.assertIsNotNone(statements,
"None returned instead of a list of statements")
self.assertIsInstance(
statements, tuple,
"Statements should be a tuple of SQL and parameter paired tuples")
self.assertEqual(
len(statements), 2,
"There should only be 2 statements in a default database")
# Run in a loop in case the default statement count changes later
for state in statements:
self.assertIsInstance(state, tuple,
"Not all statements were tuples")
self.assertIsInstance(
state[0], str, "First member of a statement wasn't a string")
self.assertIsInstance(
state[1], dict, "Second member of a statement wasn't a dict")
self.assertDictEqual(
statements[0][1], {},
"Second member isn't empty (it's all meta data that can't be escaped safely later)"
)
self.assertIn(self.testdb_name, statements[0][0],
"Test database name failed to pass into create string.")
self.assertEqual(
statements[0][0][:29], "CREATE DATABASE IF NOT EXISTS",
"First statement doesn't start with a database creation statement")
# Now we try to connect and actually run the statements that came back.
db.connection_settings = self.default_settings
db.connect()
cur = db.cursor()
for state in statements:
try:
cur.execute(state[0], state[1])
db.commit()
except mysql.connector.Error as err:
self.fail("Database Creation Failed: {0}".format(err))
def test_005_internals(self):
"""HistoriaDatabase: Test name change handling """
testName = "Historia_Tests"
db = core_data_objects.HistoriaDatabase(testName)
# Check that all default values are there and correct
self.assertEqual(db.name, testName.lower(),
"Name not assigned correctly during init")
with self.assertRaises(ValueError):
db.name = "Junk Data"
with self.assertRaises(ValueError):
db.name = "valid+junk"
with self.assertRaises(ValueError):
db.name = 12341234
db.name = "valid_database_name"
self.assertEqual(db.name, "valid_database_name",
"Name not assigned correctly after init")
def test_010_connections(self):
"""HistoriaDatabase: Connect"""
db = core_data_objects.HistoriaDatabase(None)
db.connection_settings = self.default_settings
db.connect()
self.assertIsNotNone(db.connection,
"Connection is still none after connecting")
self.assertTrue(
db.connected,
"database object not reporting being connected after connect")
self.assertTrue(
db.connection.is_connected(),
"Connection object is not reporting being connected (which means you have two problems most likely)"
)
self.assertEqual(db.connected, db.connection.is_connected(),
"Someone is lying about the connection status.")
self.assertIsNotNone(db.connection.get_server_info(),
"Got none when asking for server version.")
def test_001_construct(self):
"""HistoriaDatabase: Create new """
testName = "Historia_Tests"
db = core_data_objects.HistoriaDatabase(testName)
# Check that all default values are there and correct
self.assertEqual(db.name, testName.lower(),
"Name not assigned correctly during init")
self.assertIsNone(db.id, "id not set to None during construction")
self.assertIsInstance(db.connection_settings, dict,
"Connections settings aren't a dict")
self.assertIsInstance(db.member_classes, list,
"member classes aren't a dict")
self.assertIsInstance(db.database_defaults, dict,
"database default settings aren't a dict")
self.assertIsNone(db.connection,
"connection not set to None during construction")
self.assertIsInstance(db._logger, logging.Logger,
"logger isn't actually a logger.")
self.assertFalse(db.connected,
"Database not reporting it self as disconnected")
def tearDown(self):
# Make a good faith effort to clean up any database we created
try:
db = core_data_objects.HistoriaDatabase(None)
db.connection_settings = self.default_settings
db.connect()
cur = db.cursor()
cur.execute("DROP DATABASE `{0}`".format(self.testDBName))
db.commit()
cur.execute("DROP DATABASE `{0}`".format(self.user_db_name))
db.commit()
db.disconnect()
except Exception as err:
pass
try:
cur.execute("DROP USER {0}@{1}".format(self.user_db_name[:16],
'localhost'))
cur.execute("FLUSH PRIVILEGES")
self.db.commit()
except Exception as err:
pass # This throws errors when the users doesn't exist.
def setUp(self):
self.config = TestUserDatabase.config
self.key_file = self.config['server']['aes_key_file']
self.test_master_db_name = self.config['database']["main_database"]
self.test_user_db_name = '_'.join([self.config['database']["user_database_name_prefix"], 'user_db'])
self.default_db_settings = {
'user': self.config['database']['user'],
'password': self.config['database']['password'],
'host': self.config['database']['host'],
'database': '',
'raise_on_warnings': self.config['database']["raise_on_warnings"]
}
self.db = core_data_objects.HistoriaDatabase(self.test_master_db_name)
self.db.connection_settings = self.default_db_settings
statements = self.db.generate_database_SQL()
self.db.connect()
cur = self.db.cursor()
for state in statements:
try:
cur.execute(state[0], state[1])
self.db.commit()
except mysql.connector.Error as err:
self.fail("Unable to create master testing database: {0} \n while executing: {1}".format(err, state[0]))
def setUp(self):
self.testdb_name = type(self).config['database']["main_database"]
self.db = core_data_objects.HistoriaDatabase(self.testdb_name)
