class TestSQLDriverReconnection(unittest.TestCase): def setUp(self): """ Set up for testing reconnection to database of swift.common.key_manager.driver.sql.SQLDriver class. """ self.conf = {'crypto_keystore_sql_url': 'fake'} self.patcher = mock.patch( 'swift.common.key_manager.drivers.sql.driver.create_engine') self.mock_create_engine = self.patcher.start() self.key_driver = SQLDriver(self.conf, initialize_table=True) self.mock_connect = self.mock_create_engine.return_value.connect def tearDown(self): """ Tear down of testing reconnection to database of swift.common.key_manager.driver.sql.SQLDriver class. """ self.patcher.stop() def test_on_init(self): """ Check reconnection on driver initialization. """ self.assertEqual(self.key_driver.engine.connect.call_count, 1) def test_success(self): """ Check reconnect on happy path. """ self.mock_connect.reset_mock() self.key_driver.reconnect_to_db() self.assertEqual(self.key_driver.engine.connect.call_count, 1) def test_db_failed(self): """ Connection always fails try to fixed attempts count. """ self.mock_connect.reset_mock() self.key_driver.engine.connect.side_effect = exc.SQLAlchemyError self.assertRaises(exc.SQLAlchemyError, self.key_driver.reconnect_to_db) attempts = self.key_driver.engine.connect.call_count self.assertEquals(self.key_driver.connection_attempts, attempts) def test_failed_success(self): """ First two connections fails but third successful. """ self.mock_connect.reset_mock() connect_results = [exc.SQLAlchemyError, exc.SQLAlchemyError, 1] self.key_driver.engine.connect.side_effect = connect_results self.key_driver.reconnect_to_db() self.assertEquals(self.key_driver.engine.connect.call_count, 3)
def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path, ) self.conf = {'crypto_keystore_sql_url': self.url} self.key_driver = SQLDriver(self.conf) self.execute = mock.Mock() self.mock_conn = mock.Mock(OperationalError=exc.OperationalError) self.mock_conn.cursor.return_value = mock.Mock(execute=self.execute) engine = create_engine(self.url) meta_test.bind = engine Session.configure(bind=engine) table_template.create(engine, checkfirst=True)
def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path,) self.conf = {'crypto_keystore_sql_url': self.url} self.key_driver = SQLDriver(self.conf, initialize_table=False)
def setUp(self): """ Set up for testing reconnection to database of swift.common.key_manager.driver.sql.SQLDriver class. """ self.conf = {'crypto_keystore_sql_url': 'fake'} self.patcher = mock.patch( 'swift.common.key_manager.drivers.sql.driver.create_engine') self.mock_create_engine = self.patcher.start() self.key_driver = SQLDriver(self.conf, initialize_table=True) self.mock_connect = self.mock_create_engine.return_value.connect
def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path,) self.conf = {"crypto_keystore_sql_url": self.url} self.key_driver = SQLDriver(self.conf) self.execute = mock.Mock() self.mock_conn = mock.Mock(OperationalError=exc.OperationalError) self.mock_conn.cursor.return_value = mock.Mock(execute=self.execute) engine = create_engine(self.url) meta_test.bind = engine Session.configure(bind=engine) table_template.create(engine, checkfirst=True)
class TestSQLDriver(unittest.TestCase): def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path,) self.conf = {'crypto_keystore_sql_url': self.url} self.key_driver = SQLDriver(self.conf, initialize_table=False) def tearDown(self): """ Tear down for testing swift.common.key_manager.drivers.sql.SQLDriver. """ os.remove(self.db_path) def test_create_table(self): """ Drop table and try to create again. """ self.key_driver.create_table() table_name = key_info_table.name self.assertTrue(self.key_driver.engine.has_table(table_name)) def test_find_value(self): """ Find row in table according serching pattern. """ self.key_driver.create_table() first_acc_info = ["test_account", "test_key_string"] second_acc_info = ["test_account2", "test_key_string2"] answer1 = [('test_account', 1L, 'test_key_string')] answer2 = [('test_account2', 2L, 'test_key_string2')] for data_acc in [first_acc_info, second_acc_info]: key_info_table.insert().execute(account=data_acc[0], encryption_key=data_acc[1]) # check, that result empty , if such information not exist in DataBase self.assertFalse(self.key_driver.find_value("account", "my_account")) # check, results for currect find requests # First answer res = self.key_driver.find_value("account", first_acc_info[0]) self.assertEquals(res, answer1) res = self.key_driver.find_value("encryption_key", first_acc_info[1]) self.assertEquals(res, answer1) res = self.key_driver.find_value("key_id", "1") self.assertEquals(res, answer1) # Second answer res = self.key_driver.find_value("account", second_acc_info[0]) self.assertEquals(res, answer2) res = self.key_driver.find_value("encryption_key", second_acc_info[1]) self.assertEquals(res, answer2) res = self.key_driver.find_value("key_id", "2") self.assertEquals(res, answer2) def test_get_key_id(self): """ Check key_id value for different account values. """ self.key_driver.create_table() acc_info = ["acc1", "acc2"] # check key_id for first account (account not existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check key_id for first account (account existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check that account not created again (account existed) self.assertNotEqual(self.key_driver.get_key_id(acc_info[0]), 2) # check key_id for second account self.assertEqual(self.key_driver.get_key_id(acc_info[1]), 2) def test_get_key(self): """ Check key value for different account and key_id values. """ self.key_driver.create_table() # create 2 account with key_id acc_info = ["acc1", "acc2"] for acc in acc_info: key_info_table.insert().execute(account=acc) # check key for first account key1 = self.key_driver.get_key(1) key2 = self.key_driver.get_key(1) self.assertEqual(key1, key2) # check key for second account key3 = self.key_driver.get_key(2) self.assertNotEqual(key2, key3) # check raise, if incorrect id (no in table) self.assertRaises(StandardError, self.key_driver.get_key, 100) # check raise, if incorrect id (string and have not only digits) self.assertRaises(ValueError, self.key_driver.get_key, "id100") # check raise, if incorrect id (not string or int) test = [[2], {"test": "test"}, (222, 2)] for val in test: self.assertRaises(TypeError, self.key_driver.get_key, val) @mock.patch('migrate.versioning.api.upgrade') def test_sync_success(self, mock_upgrade): """ Successful migration. """ self.key_driver.create_table() self.key_driver.sync() mock_upgrade.assert_called_once_with(self.url, mock.ANY) @mock.patch('migrate.versioning.api.version_control') @mock.patch('migrate.versioning.api.upgrade') def test_sync_failed(self, mock_upgrade, mock_version_control): """ Version control table doesn't exist. """ self.key_driver.create_table() mock_upgrade.side_effect = [DatabaseNotControlledError, None] self.key_driver.sync() mock_upgrade.assert_has_calls(2 * [mock.call(self.url, mock.ANY)]) mock_version_control.assert_called_once_with(self.url, mock.ANY)
class TestSQLDriver(unittest.TestCase): def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path, ) self.conf = {'crypto_keystore_sql_url': self.url} self.key_driver = SQLDriver(self.conf) self.execute = mock.Mock() self.mock_conn = mock.Mock(OperationalError=exc.OperationalError) self.mock_conn.cursor.return_value = mock.Mock(execute=self.execute) engine = create_engine(self.url) meta_test.bind = engine Session.configure(bind=engine) table_template.create(engine, checkfirst=True) def tearDown(self): """ Tear down for testing swift.common.key_manager.drivers.sql.SQLDriver. """ os.remove(self.db_path) def test_get_key_id(self): """ Check key_id value for different account values. """ acc_info = ["acc1", "acc2"] # check key_id for first account (account not existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check key_id for first account (account existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check that account not created again (account existed) self.assertNotEqual(self.key_driver.get_key_id(acc_info[0]), 2) # check key_id for second account self.assertEqual(self.key_driver.get_key_id(acc_info[1]), 2) def test_get_key(self): """ Check key value for different account and key_id values. """ # create 2 account with key_id acc_info = ["acc1", "acc2"] session = Session() for acc in acc_info: session.add(Key(acc, generate_key())) session.commit() # check key for first account key1 = self.key_driver.get_key(1) key2 = self.key_driver.get_key(1) self.assertEqual(key1, key2) # check key for second account key3 = self.key_driver.get_key(2) self.assertNotEqual(key2, key3) # check raise, if incorrect id (no in table) self.assertRaises(StandardError, self.key_driver.get_key, 100) session.close() @mock.patch('migrate.versioning.api.upgrade') def test_sync_success(self, mock_upgrade): """ Successful migration. """ self.key_driver.sync() mock_upgrade.assert_called_once_with(self.url, mock.ANY) @mock.patch('migrate.versioning.api.version_control') @mock.patch('migrate.versioning.api.upgrade') def test_sync_failed(self, mock_upgrade, mock_version_control): """ Version control table doesn't exist. """ mock_upgrade.side_effect = [DatabaseNotControlledError, None] self.key_driver.sync() mock_upgrade.assert_has_calls(2 * [mock.call(self.url, mock.ANY)]) mock_version_control.assert_called_once_with(self.url, mock.ANY) def test_invalid_key_id(self): self.assertRaises(ValueError, self.key_driver.validate_key_id, "n0tnumb3r") self.assertRaises(ValueError, self.key_driver.validate_key_id, "-13") def test_valid_key_id(self): self.assertEqual(None, self.key_driver.validate_key_id("42")) def test_succesful_ping(self): self.execute.return_value = None self.assertEqual(None, ping_connection(self.mock_conn, None, None)) def test_connection_problems(self): error = exc.OperationalError(None, None, None) #typical situation when connection should be removed from a pool for code in (2006, 2013, 2014, 2045, 2055): error.args = [code, 'connection need to be removed'] self.execute.side_effect = error self.assertRaises(exc.DisconnectionError, ping_connection, self.mock_conn, None, None) def test_unknown_problem(self): error = exc.OperationalError(None, None, None) #expected exception type with unexpected error code, raised further error.args = [2000, "CR_UNKNOWN_ERROR"] self.execute.side_effect = error self.assertRaises(exc.OperationalError, ping_connection, self.mock_conn, None, None) error = StandardError() #unexpected error, shouldn't be catched error.args = [42, 'all is lost'] self.execute.side_effect = error self.assertRaises(StandardError, ping_connection, self.mock_conn, None, None)
class TestSQLDriver(unittest.TestCase): def setUp(self): """ Set up for testing swift.common.key_manager.drivers.sql.SQLDriver. """ self.db_path = tempfile.mktemp() self.url = "sqlite:///%s" % (self.db_path,) self.conf = {"crypto_keystore_sql_url": self.url} self.key_driver = SQLDriver(self.conf) self.execute = mock.Mock() self.mock_conn = mock.Mock(OperationalError=exc.OperationalError) self.mock_conn.cursor.return_value = mock.Mock(execute=self.execute) engine = create_engine(self.url) meta_test.bind = engine Session.configure(bind=engine) table_template.create(engine, checkfirst=True) def tearDown(self): """ Tear down for testing swift.common.key_manager.drivers.sql.SQLDriver. """ os.remove(self.db_path) def test_get_key_id(self): """ Check key_id value for different account values. """ acc_info = ["acc1", "acc2"] # check key_id for first account (account not existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check key_id for first account (account existed) self.assertEqual(self.key_driver.get_key_id(acc_info[0]), 1) # check that account not created again (account existed) self.assertNotEqual(self.key_driver.get_key_id(acc_info[0]), 2) # check key_id for second account self.assertEqual(self.key_driver.get_key_id(acc_info[1]), 2) def test_get_key(self): """ Check key value for different account and key_id values. """ # create 2 account with key_id acc_info = ["acc1", "acc2"] session = Session() for acc in acc_info: session.add(Key(acc, generate_key())) session.commit() # check key for first account key1 = self.key_driver.get_key(1) key2 = self.key_driver.get_key(1) self.assertEqual(key1, key2) # check key for second account key3 = self.key_driver.get_key(2) self.assertNotEqual(key2, key3) # check raise, if incorrect id (no in table) self.assertRaises(StandardError, self.key_driver.get_key, 100) session.close() @mock.patch("migrate.versioning.api.upgrade") def test_sync_success(self, mock_upgrade): """ Successful migration. """ self.key_driver.sync() mock_upgrade.assert_called_once_with(self.url, mock.ANY) @mock.patch("migrate.versioning.api.version_control") @mock.patch("migrate.versioning.api.upgrade") def test_sync_failed(self, mock_upgrade, mock_version_control): """ Version control table doesn't exist. """ mock_upgrade.side_effect = [DatabaseNotControlledError, None] self.key_driver.sync() mock_upgrade.assert_has_calls(2 * [mock.call(self.url, mock.ANY)]) mock_version_control.assert_called_once_with(self.url, mock.ANY) def test_invalid_key_id(self): self.assertRaises(ValueError, self.key_driver.validate_key_id, "n0tnumb3r") self.assertRaises(ValueError, self.key_driver.validate_key_id, "-13") def test_valid_key_id(self): self.assertEqual(None, self.key_driver.validate_key_id("42")) def test_succesful_ping(self): self.execute.return_value = None self.assertEqual(None, ping_connection(self.mock_conn, None, None)) def test_connection_problems(self): error = exc.OperationalError(None, None, None) # typical situation when connection should be removed from a pool for code in (2006, 2013, 2014, 2045, 2055): error.args = [code, "connection need to be removed"] self.execute.side_effect = error self.assertRaises(exc.DisconnectionError, ping_connection, self.mock_conn, None, None) def test_unknown_problem(self): error = exc.OperationalError(None, None, None) # expected exception type with unexpected error code, raised further error.args = [2000, "CR_UNKNOWN_ERROR"] self.execute.side_effect = error self.assertRaises(exc.OperationalError, ping_connection, self.mock_conn, None, None) error = StandardError() # unexpected error, shouldn't be catched error.args = [42, "all is lost"] self.execute.side_effect = error self.assertRaises(StandardError, ping_connection, self.mock_conn, None, None)