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)