openstack
/
trove
Code Issues Proposed changes

Correct errors resulting in "No handlers ..." error message 

This is a checkin for the issue of having errors that read "No
handlers could be found for logger X.Y.Z" when running tests. While
being annoying, it is also a serious issue in that some times, the
lack of logging masks errors in the tests. One such example is fixed
in this chkin (see bug 1491093).

Change-Id: I4066d226aefbd23248e88692db109d31f5c150e9
Partial-Bug: #1491075
Closes-Bug: #1491093
This commit is contained in:
Amrith Kumar 2015-10-17 18:29:57 -04:00
parent 709a33f8be
commit 34ce70e299
30 changed files with 383 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
run_tests.py
View File

@ -35,6 +35,7 @@ from trove.common.rpc import version as rpc_version
from trove.common import utils
from trove import rpc
from trove.tests.config import CONFIG
from trove.tests import root_logger
eventlet.monkey_patch(thread=False)
@ -61,6 +62,8 @@ def add_support_for_localization():
def initialize_trove(config_file):
from trove.common import pastedeploy
root_logger.DefaultRootLogger()
cfg.CONF(args=[],
project='trove',
default_config_files=[config_file])

70
trove/tests/root_logger.py Normal file
View File

@ -0,0 +1,70 @@
# Copyright 2015 Tesora Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import logging
import traceback
class DefaultRootHandler(logging.StreamHandler):
"""A singleton StreamHandler"""
__handler = logging.StreamHandler()
__singleton = None
__info = None
@classmethod
def activate(cls):
# leverage the singleton __handler which has an
# acquire() method to create a critical section.
cls.__handler.acquire()
if cls.__singleton is None:
cls.__singleton = DefaultRootHandler()
cls.__handler.release()
return cls.__singleton
@classmethod
def set_info(cls, info=None):
cls.__info = info
def __init__(self):
if DefaultRootHandler.__singleton is not None:
raise Exception(
"Do not directly instantiate DefaultRootHandler(). "
"Only use the activate() class method.")
super(DefaultRootHandler, self).__init__()
def emit(self, record):
msg = ("[" + record.name + "]\n" +
self.format(record) + "\n" +
(("\tFrom: " + DefaultRootHandler.__info + "\n")
if DefaultRootHandler.__info
else (''.join(traceback.format_stack()))))
self.stream.write(msg)
self.flush()
class DefaultRootLogger(object):
"""A root logger that uses the singleton handler"""
def __init__(self):
super(DefaultRootLogger, self).__init__()
handler = DefaultRootHandler.activate()
handler.acquire()
if handler not in logging.getLogger('').handlers:
logging.getLogger('').addHandler(handler)
handler.release()

13
trove/tests/unittests/backup/test_backupagent.py
View File

@ -383,7 +383,8 @@ class BackupAgentTest(trove_testtools.TestCase):
@patch.object(conductor_api.API, 'get_client', Mock(return_value=Mock()))
@patch.object(conductor_api.API, 'update_backup',
Mock(return_value=Mock()))
def test_execute_lossy_backup(self):
@patch('trove.guestagent.backup.backupagent.LOG')
def test_execute_lossy_backup(self, mock_logging):
"""This test verifies that incomplete writes to swift will fail."""
with patch.object(MockSwift, 'save',
return_value=(False, 'Error', 'y', 'z')):
@ -430,7 +431,8 @@ class BackupAgentTest(trove_testtools.TestCase):
bkup_info,
'/var/lib/mysql/data')
def test_restore_unknown(self):
@patch('trove.guestagent.backup.backupagent.LOG')
def test_restore_unknown(self, mock_logging):
with patch.object(backupagent, 'get_restore_strategy',
side_effect=ImportError):
@ -451,7 +453,8 @@ class BackupAgentTest(trove_testtools.TestCase):
@patch.object(MockSwift, 'load_metadata', return_value={'lsn': '54321'})
@patch.object(MockStorage, 'save_metadata')
@patch.object(backupagent, 'get_storage_strategy', return_value=MockSwift)
def test_backup_incremental_metadata(self,
@patch('trove.guestagent.backup.backupagent.LOG')
def test_backup_incremental_metadata(self, mock_logging,
get_storage_strategy_mock,
save_metadata_mock,
load_metadata_mock,
@ -471,7 +474,9 @@ class BackupAgentTest(trove_testtools.TestCase):
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
'parent': {'location': 'fake', 'checksum': 'md5'}
'parent': {'location': 'fake', 'checksum': 'md5'},
'datastore': 'mysql',
'datastore_version': 'bo.gus'
}
agent.execute_backup(TroveContext(),

12
trove/tests/unittests/backup/test_storage.py
View File

@ -63,7 +63,8 @@ class SwiftStorageSaveChecksumTests(trove_testtools.TestCase):
location,
"Incorrect swift location was returned.")
def test_swift_segment_checksum_etag_mismatch(self):
@patch('trove.guestagent.strategies.storage.swift.LOG')
def test_swift_segment_checksum_etag_mismatch(self, mock_logging):
"""This tests that when etag doesn't match segment uploaded checksum
False is returned and None for checksum and location
"""
@ -96,7 +97,8 @@ class SwiftStorageSaveChecksumTests(trove_testtools.TestCase):
location,
"Incorrect swift location was returned.")
def test_swift_checksum_etag_mismatch(self):
@patch('trove.guestagent.strategies.storage.swift.LOG')
def test_swift_checksum_etag_mismatch(self, mock_logging):
"""This tests that when etag doesn't match swift checksum False is
returned and None for checksum and location
"""
@ -157,7 +159,8 @@ class SwiftStorageUtils(trove_testtools.TestCase):
match = self.swift._verify_checksum('"my-good-etag"', 'my-good-etag')
self.assertTrue(match)
def test_verify_checksum_bad(self):
@patch('trove.guestagent.strategies.storage.swift.LOG')
def test_verify_checksum_bad(self, mock_logging):
self.assertRaises(SwiftDownloadIntegrityError,
self.swift._verify_checksum,
'"THE-GOOD-THE-BAD"',
@ -192,7 +195,8 @@ class SwiftStorageLoad(trove_testtools.TestCase):
download_stream = storage_strategy.load(location, backup_checksum)
self.assertIsNotNone(download_stream)
def test_run_verify_checksum_mismatch(self):
@patch('trove.guestagent.strategies.storage.swift.LOG')
def test_run_verify_checksum_mismatch(self, mock_logging):
"""This tests that SwiftDownloadIntegrityError is raised and swift
download cmd does not run when original backup checksum
does not match swift object etag

6
trove/tests/unittests/cluster/test_cluster.py
View File

@ -143,7 +143,8 @@ class ClusterTest(trove_testtools.TestCase):
None
)
def test_delete_bad_task_status(self):
@patch('trove.cluster.models.LOG')
def test_delete_bad_task_status(self, mock_logging):
self.cluster.db_info.task_status = ClusterTasks.BUILDING_INITIAL
self.assertRaises(exception.UnprocessableEntity,
self.cluster.delete)
@ -170,7 +171,8 @@ class ClusterTest(trove_testtools.TestCase):
self.cluster.delete()
mock_update_db.assert_called_with(task_status=ClusterTasks.DELETING)
def test_add_shard_bad_task_status(self):
@patch('trove.common.strategies.cluster.experimental.mongodb.api.LOG')
def test_add_shard_bad_task_status(self, mock_logging):
task_status = ClusterTasks.BUILDING_INITIAL
self.cluster.db_info.task_status = task_status
self.assertRaises(exception.UnprocessableEntity,

3
trove/tests/unittests/cluster/test_pxc_cluster.py
View File

@ -273,7 +273,8 @@ class ClusterTest(trove_testtools.TestCase):
mock_db_create.return_value.id)
self.assertEqual(3, mock_ins_create.call_count)
def test_delete_bad_task_status(self):
@patch('trove.cluster.models.LOG')
def test_delete_bad_task_status(self, mock_logging):
self.cluster.db_info.task_status = ClusterTasks.BUILDING_INITIAL
self.assertRaises(exception.UnprocessableEntity,
self.cluster.delete)

3
trove/tests/unittests/cluster/test_redis_cluster.py
View File

@ -243,7 +243,8 @@ class ClusterTest(trove_testtools.TestCase):
self.cluster.shrink(['id1'])
self.assertEqual(1, mock_ins_delete.call_count)
def test_delete_bad_task_status(self):
@patch('trove.cluster.models.LOG')
def test_delete_bad_task_status(self, mock_logging):
self.cluster.db_info.task_status = ClusterTasks.BUILDING_INITIAL
self.assertRaises(exception.UnprocessableEntity,
self.cluster.delete)

3
trove/tests/unittests/cluster/test_vertica_cluster.py
View File

@ -258,7 +258,8 @@ class ClusterTest(trove_testtools.TestCase):
mock_db_create.return_value.id)
self.assertEqual(3, mock_ins_create.call_count)
def test_delete_bad_task_status(self):
@patch('trove.cluster.models.LOG')
def test_delete_bad_task_status(self, mock_logging):
self.cluster.db_info.task_status = ClusterTasks.BUILDING_INITIAL
self.assertRaises(exception.UnprocessableEntity,
self.cluster.delete)

27
trove/tests/unittests/conductor/test_methods.py
View File

@ -12,6 +12,8 @@
# License for the specific language governing permissions and limitations
# under the License.
from mock import patch
from trove.backup import models as bkup_models
from trove.backup import state
from trove.common import exception as t_exception
@ -74,7 +76,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
self.assertRaises(t_exception.ModelNotFoundError,
self.cond_mgr.heartbeat, None, new_id, {})
def test_heartbeat_instance_no_changes(self):
@patch('trove.conductor.manager.LOG')
def test_heartbeat_instance_no_changes(self, mock_logging):
iss_id = self._create_iss()
old_iss = self._get_iss(iss_id)
self.cond_mgr.heartbeat(None, self.instance_id, {})
@ -83,7 +86,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
self.assertEqual(old_iss.status_description,
new_iss.status_description)
def test_heartbeat_instance_status_bogus_change(self):
@patch('trove.conductor.manager.LOG')
def test_heartbeat_instance_status_bogus_change(self, mock_logging):
iss_id = self._create_iss()
old_iss = self._get_iss(iss_id)
new_status = 'potato salad'
@ -97,7 +101,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
self.assertEqual(old_iss.status_description,
new_iss.status_description)
def test_heartbeat_instance_status_changed(self):
@patch('trove.conductor.manager.LOG')
def test_heartbeat_instance_status_changed(self, mock_logging):
iss_id = self._create_iss()
payload = {'service_status': ServiceStatuses.BUILDING.description}
self.cond_mgr.heartbeat(None, self.instance_id, payload)
@ -112,7 +117,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
self.cond_mgr.update_backup,
None, self.instance_id, new_bkup_id)
def test_backup_instance_id_nomatch(self):
@patch('trove.conductor.manager.LOG')
def test_backup_instance_id_nomatch(self, mock_logging):
new_iid = utils.generate_uuid()
bkup_id = self._create_backup('nomatch')
old_name = self._get_backup(bkup_id).name
@ -121,14 +127,16 @@ class ConductorMethodTests(trove_testtools.TestCase):
bkup = self._get_backup(bkup_id)
self.assertEqual(old_name, bkup.name)
def test_backup_bogus_fields_not_changed(self):
@patch('trove.conductor.manager.LOG')
def test_backup_bogus_fields_not_changed(self, mock_logging):
bkup_id = self._create_backup('bogus')
self.cond_mgr.update_backup(None, self.instance_id, bkup_id,
not_a_valid_field="INVALID")
bkup = self._get_backup(bkup_id)
self.assertFalse(hasattr(bkup, 'not_a_valid_field'))
def test_backup_real_fields_changed(self):
@patch('trove.conductor.manager.LOG')
def test_backup_real_fields_changed(self, mock_logging):
bkup_id = self._create_backup('realrenamed')
new_name = "recently renamed"
self.cond_mgr.update_backup(None, self.instance_id, bkup_id,
@ -137,8 +145,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
self.assertEqual(new_name, bkup.name)
# --- Tests for discarding old messages ---
def test_heartbeat_newer_timestamp_accepted(self):
@patch('trove.conductor.manager.LOG')
def test_heartbeat_newer_timestamp_accepted(self, mock_logging):
new_p = {'service_status': ServiceStatuses.NEW.description}
build_p = {'service_status': ServiceStatuses.BUILDING.description}
iss_id = self._create_iss()
@ -150,7 +158,8 @@ class ConductorMethodTests(trove_testtools.TestCase):
iss = self._get_iss(iss_id)
self.assertEqual(ServiceStatuses.BUILDING, iss.status)
def test_heartbeat_older_timestamp_discarded(self):
@patch('trove.conductor.manager.LOG')
def test_heartbeat_older_timestamp_discarded(self, mock_logging):
new_p = {'service_status': ServiceStatuses.NEW.description}
build_p = {'service_status': ServiceStatuses.BUILDING.description}
iss_id = self._create_iss()

4
trove/tests/unittests/guestagent/test_agent_heartbeats_models.py
View File

@ -11,6 +11,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from mock import patch
import uuid
from trove.common import exception
@ -103,7 +104,8 @@ class AgentHeartBeatTest(trove_testtools.TestCase):
self.assertIsNone(heartbeat_found)
self.assertTrue(exception_raised)
def test_find_by_instance_id_not_found(self):
@patch('trove.guestagent.models.LOG')
def test_find_by_instance_id_not_found(self, mock_logging):
"""
Test to retrieve a guest agents when id is not found
"""

12
trove/tests/unittests/guestagent/test_api.py
View File

@ -92,12 +92,14 @@ class ApiTest(trove_testtools.TestCase):
self._verify_rpc_prepare_before_cast()
self._verify_cast('create_user', users='test_user')
def test_api_cast_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_cast_exception(self, mock_logging):
self.call_context.cast.side_effect = IOError('host down')
self.assertRaises(exception.GuestError, self.api.create_user,
'test_user')
def test_api_call_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_call_exception(self, mock_logging):
self.call_context.call.side_effect = IOError('host_down')
self.assertRaises(exception.GuestError, self.api.list_users)
@ -105,12 +107,14 @@ class ApiTest(trove_testtools.TestCase):
self.call_context.call.side_effect = Timeout()
self.assertRaises(exception.GuestTimeout, self.api.restart)
def test_api_cast_remote_error(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_cast_remote_error(self, mock_logging):
self.call_context.cast.side_effect = RemoteError('Error')
self.assertRaises(exception.GuestError, self.api.delete_database,
'test_db')
def test_api_call_remote_error(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_call_remote_error(self, mock_logging):
self.call_context.call.side_effect = RemoteError('Error')
self.assertRaises(exception.GuestError, self.api.stop_db)

4
trove/tests/unittests/guestagent/test_couchbase_manager.py
View File

@ -158,7 +158,9 @@ class GuestAgentCouchbaseManagerTest(testtools.TestCase):
self.assertEqual(stat.S_IRUSR, filepermissions & 0o777)
@mock.patch.object(utils, 'execute_with_timeout', Mock(return_value=0))
def test_write_password_to_file2(self):
@mock.patch(
'trove.guestagent.datastore.experimental.couchbase.service.LOG')
def test_write_password_to_file2(self, mock_logging):
self.original_mkstemp = tempfile.mkstemp
self.tempname = None

158
trove/tests/unittests/guestagent/test_dbaas.py
View File

@ -158,7 +158,9 @@ class DbaasTest(testtools.TestCase):
mock_remove.assert_not_called()
@patch.object(operating_system, 'remove')
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_fail_password_update_content_clear_expired_password(self,
mock_logging,
mock_remove):
secret_content = ("# The random password set for the "
"root user at Wed May 14 14:06:38 2014 "
@ -170,12 +172,14 @@ class DbaasTest(testtools.TestCase):
self.assertEqual(2, dbaas_base.utils.execute.call_count)
mock_remove.assert_not_called()
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch.object(operating_system, 'remove')
@patch.object(dbaas_base.utils, 'execute',
side_effect=ProcessExecutionError)
def test_fail_retrieve_secret_content_clear_expired_password(self,
mock_execute,
mock_remove):
mock_remove,
mock_logging):
dbaas_base.clear_expired_password()
self.assertEqual(1, mock_execute.call_count)
mock_remove.assert_not_called()
@ -686,7 +690,8 @@ class MySqlAdminTest(testtools.TestCase):
self.assertTrue(text in args[0].text, "%s not in query." % text)
self.assertEqual(1, mock_associate_dbs.call_count)
def test_fail_get_user(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_fail_get_user(self, *args):
username = "os_admin"
hostname = "host"
self.assertRaisesRegexp(BadRequest, "Username os_admin is not valid",
@ -709,7 +714,8 @@ class MySqlAdminTest(testtools.TestCase):
self.assertTrue(dbaas.LocalSqlClient.execute.called,
"The client object was not called")
def test_fail_grant_access(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_fail_grant_access(self, *args):
user = MagicMock()
user.name = "test_user"
user.host = "%"
@ -872,16 +878,20 @@ class MySqlAppTest(testtools.TestCase):
rd_instance.ServiceStatuses.SHUTDOWN.description}))
self.assertEqual(2, mock_execute.call_count)
def test_stop_mysql_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_stop_mysql_error(self, *args):
dbaas_base.utils.execute_with_timeout = Mock()
self.appStatus.set_next_status(rd_instance.ServiceStatuses.RUNNING)
self.mySqlApp.state_change_wait_time = 1
self.assertRaises(RuntimeError, self.mySqlApp.stop_db)
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch.object(operating_system, 'service_discovery',
side_effect=KeyError('error'))
@patch.object(utils, 'execute_with_timeout')
def test_stop_mysql_key_error(self, mock_execute, mock_service):
def test_stop_mysql_key_error(self, mock_execute, mock_service,
mock_logging):
self.assertRaisesRegexp(RuntimeError, 'Service is not discovered.',
self.mySqlApp.stop_db)
self.assertEqual(0, mock_execute.call_count)
@ -915,8 +925,9 @@ class MySqlAppTest(testtools.TestCase):
self.assertFalse(self.mySqlApp.start_mysql.called)
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch.object(dbaas.MySqlApp, 'get_data_dir', return_value='some path')
def test_wipe_ib_logfiles_error(self, get_datadir_mock):
def test_wipe_ib_logfiles_error(self, get_datadir_mock, mock_logging):
mocked = Mock(side_effect=ProcessExecutionError('Error'))
dbaas_base.utils.execute_with_timeout = mocked
@ -944,7 +955,9 @@ class MySqlAppTest(testtools.TestCase):
{'service_status':
rd_instance.ServiceStatuses.RUNNING.description}))
def test_start_mysql_runs_forever(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch('trove.guestagent.datastore.service.LOG')
def test_start_mysql_runs_forever(self, *args):
dbaas_base.utils.execute_with_timeout = Mock()
self.mySqlApp._enable_mysql_on_boot = Mock()
@ -957,7 +970,9 @@ class MySqlAppTest(testtools.TestCase):
{'service_status':
rd_instance.ServiceStatuses.SHUTDOWN.description}))
def test_start_mysql_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_start_mysql_error(self, *args):
self.mySqlApp._enable_mysql_on_boot = Mock()
mocked = Mock(side_effect=ProcessExecutionError('Error'))
@ -979,7 +994,8 @@ class MySqlAppTest(testtools.TestCase):
self.assertEqual(rd_instance.ServiceStatuses.RUNNING,
self.appStatus._get_actual_db_status())
def test_start_db_with_conf_changes_mysql_is_running(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_start_db_with_conf_changes_mysql_is_running(self, *args):
self.mySqlApp.start_mysql = Mock()
self.appStatus.status = rd_instance.ServiceStatuses.RUNNING
@ -1022,10 +1038,12 @@ class MySqlAppTest(testtools.TestCase):
mock_execute.assert_called_with(mysql_service['cmd_enable'],
shell=True)
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch.object(operating_system, 'service_discovery',
side_effect=KeyError('error'))
@patch.object(utils, 'execute_with_timeout')
def test_fail__enable_mysql_on_boot(self, mock_execute, mock_service):
def test_fail__enable_mysql_on_boot(self, mock_execute, mock_service,
mock_logging):
self.assertRaisesRegexp(RuntimeError, 'Service is not discovered.',
self.mySqlApp._enable_mysql_on_boot)
self.assertEqual(0, mock_execute.call_count)
@ -1039,10 +1057,12 @@ class MySqlAppTest(testtools.TestCase):
mock_execute.assert_called_with(mysql_service['cmd_disable'],
shell=True)
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
@patch.object(operating_system, 'service_discovery',
side_effect=KeyError('error'))
@patch.object(utils, 'execute_with_timeout')
def test_fail__disable_mysql_on_boot(self, mock_execute, mock_service):
def test_fail__disable_mysql_on_boot(self, mock_execute, mock_service,
mock_logging):
self.assertRaisesRegexp(RuntimeError, 'Service is not discovered.',
self.mySqlApp._disable_mysql_on_boot)
self.assertEqual(0, mock_execute.call_count)
@ -1603,7 +1623,8 @@ class InterrogatorTest(testtools.TestCase):
self.assertEqual(2147483648, result['free'])
self.assertEqual(2.0, result['used'])
def test_get_filesystem_volume_stats_error(self):
@patch('trove.guestagent.dbaas.LOG')
def test_get_filesystem_volume_stats_error(self, *args):
with patch.object(os, 'statvfs', side_effect=OSError):
self.assertRaises(
RuntimeError,
@ -2144,14 +2165,17 @@ class MySqlAppStatusTest(testtools.TestCase):
@patch.object(utils, 'execute_with_timeout',
side_effect=ProcessExecutionError())
@patch.object(os.path, 'exists', return_value=True)
def test_get_actual_db_status_error_crashed(self, mock_exists,
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_get_actual_db_status_error_crashed(self, mock_logging,
mock_exists,
mock_execute):
dbaas_base.load_mysqld_options = Mock(return_value={})
self.mySqlAppStatus = MySqlAppStatus.get()
status = self.mySqlAppStatus._get_actual_db_status()
self.assertEqual(rd_instance.ServiceStatuses.CRASHED, status)
def test_get_actual_db_status_error_shutdown(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_get_actual_db_status_error_shutdown(self, *args):
mocked = Mock(side_effect=ProcessExecutionError())
dbaas_base.utils.execute_with_timeout = mocked
@ -2163,7 +2187,8 @@ class MySqlAppStatusTest(testtools.TestCase):
self.assertEqual(rd_instance.ServiceStatuses.SHUTDOWN, status)
def test_get_actual_db_status_error_blocked(self):
@patch('trove.guestagent.datastore.mysql_common.service.LOG')
def test_get_actual_db_status_error_blocked(self, *args):
dbaas_base.utils.execute_with_timeout = MagicMock(
side_effect=[ProcessExecutionError(), ("some output", None)])
@ -2295,7 +2320,8 @@ class TestRedisApp(testtools.TestCase):
self.assertTrue(
mock_status.wait_for_real_status_to_change_to.called)
def test_stop_db_with_failure(self):
@patch('trove.guestagent.datastore.experimental.redis.service.LOG')
def test_stop_db_with_failure(self, *args):
mock_status = MagicMock()
mock_status.wait_for_real_status_to_change_to = MagicMock(
return_value=True)
@ -2336,8 +2362,9 @@ class TestRedisApp(testtools.TestCase):
self._assert_start_redis(mock_status)
@patch('trove.guestagent.datastore.experimental.redis.service.LOG')
@patch.object(utils, 'execute_with_timeout')
def test_start_redis_with_failure(self, exec_mock):
def test_start_redis_with_failure(self, exec_mock, mock_logging):
mock_status = MagicMock()
mock_status.wait_for_real_status_to_change_to = MagicMock(
return_value=False)
@ -2419,7 +2446,9 @@ class CassandraDBAppTest(testtools.TestCase):
{'service_status':
rd_instance.ServiceStatuses.SHUTDOWN.description}))
def test_stop_db_error(self):
@patch('trove.guestagent.datastore.experimental.cassandra.service.LOG')
@patch('trove.guestagent.datastore.service.LOG')
def test_stop_db_error(self, *args):
cass_service.utils.execute_with_timeout = Mock()
self.appStatus.set_next_status(rd_instance.ServiceStatuses.RUNNING)
@ -2448,7 +2477,8 @@ class CassandraDBAppTest(testtools.TestCase):
self.cassandra.start_db()
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_start_cassandra_runs_forever(self):
@patch('trove.guestagent.datastore.experimental.cassandra.service.LOG')
def test_start_cassandra_runs_forever(self, *args):
cass_service.utils.execute_with_timeout = Mock()
(self.cassandra.status.
@ -2474,7 +2504,9 @@ class CassandraDBAppTest(testtools.TestCase):
rd_instance.ServiceStatuses.RUNNING.description}))
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_start_cassandra_error(self):
@patch('trove.guestagent.datastore.experimental.cassandra.service.LOG')
@patch('trove.guestagent.datastore.service.LOG')
def test_start_cassandra_error(self, *args):
self.cassandra._enable_db_on_boot = Mock()
self.cassandra.state_change_wait_time = 1
cass_service.utils.execute_with_timeout = Mock(
@ -2504,7 +2536,8 @@ class CassandraDBAppTest(testtools.TestCase):
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_cassandra_error_in_write_config_verify_unlink(self):
@patch('trove.guestagent.datastore.experimental.cassandra.service.LOG')
def test_cassandra_error_in_write_config_verify_unlink(self, *args):
# this test verifies not only that the write_config
# method properly invoked execute, but also that it properly
# attempted to unlink the file (as a result of the exception)
@ -2622,7 +2655,9 @@ class CouchbaseAppTest(testtools.TestCase):
self.couchbaseApp.stop_db()
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_stop_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.couchbase.service.LOG')
def test_stop_db_error(self, *args):
couchservice.utils.execute_with_timeout = Mock()
self.appStatus.set_next_status(rd_instance.ServiceStatuses.RUNNING)
self.couchbaseApp.state_change_wait_time = 1
@ -2650,14 +2685,18 @@ class CouchbaseAppTest(testtools.TestCase):
self.couchbaseApp.start_db()
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_start_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.couchbase.service.LOG')
def test_start_db_error(self, *args):
mocked = Mock(side_effect=ProcessExecutionError('Error'))
couchservice.utils.execute_with_timeout = mocked
self.couchbaseApp._enable_db_on_boot = Mock()
self.assertRaises(RuntimeError, self.couchbaseApp.start_db)
def test_start_db_runs_forever(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.couchbase.service.LOG')
def test_start_db_runs_forever(self, *args):
couchservice.utils.execute_with_timeout = Mock()
self.couchbaseApp._enable_db_on_boot = Mock()
self.couchbaseApp.state_change_wait_time = 1
@ -2729,7 +2768,9 @@ class CouchDBAppTest(testtools.TestCase):
self.couchdbApp.stop_db()
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_stop_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.couchdb.service.LOG')
def test_stop_db_error(self, *args):
couchdb_service.utils.execute_with_timeout = Mock()
self.appStatus.set_next_status(rd_instance.ServiceStatuses.RUNNING)
self.couchdbApp.state_change_wait_time = 1
@ -2757,7 +2798,9 @@ class CouchDBAppTest(testtools.TestCase):
self.couchdbApp.start_db()
self.assert_reported_status(rd_instance.ServiceStatuses.NEW)
def test_start_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.couchdb.service.LOG')
def test_start_db_error(self, *args):
couchdb_service.utils.execute_with_timeout = Mock(
side_effect=ProcessExecutionError('Error'))
self.couchdbApp._enable_db_on_boot = Mock()
@ -2842,7 +2885,9 @@ class MongoDBAppTest(testtools.TestCase):
self.assertTrue(conductor_api.API.heartbeat.called_once_with(
self.FAKE_ID, {'service_status': 'shutdown'}))
def test_stop_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.mongodb.service.LOG')
def test_stop_db_error(self, *args):
mongo_service.utils.execute_with_timeout = Mock()
self.mongoDbApp.status.set_next_status(
@ -2887,7 +2932,9 @@ class MongoDBAppTest(testtools.TestCase):
self.assertTrue(conductor_api.API.heartbeat.called_once_with(
self.FAKE_ID, {'service_status': 'running'}))
def test_start_db_runs_forever(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.mongodb.service.LOG')
def test_start_db_runs_forever(self, *args):
mongo_service.utils.execute_with_timeout = Mock(
return_value=["ubuntu 17036 0.0 0.1 618960 "
@ -2900,7 +2947,9 @@ class MongoDBAppTest(testtools.TestCase):
self.assertTrue(conductor_api.API.heartbeat.called_once_with(
self.FAKE_ID, {'service_status': 'shutdown'}))
def test_start_db_error(self):
@patch('trove.guestagent.datastore.service.LOG')
@patch('trove.guestagent.datastore.experimental.mongodb.service.LOG')
def test_start_db_error(self, *args):
self.mongoDbApp._enable_db_on_boot = Mock()
mocked = Mock(side_effect=ProcessExecutionError('Error'))
@ -2964,7 +3013,8 @@ class VerticaAppStatusTest(testtools.TestCase):
status = self.verticaAppStatus._get_actual_db_status()
self.assertEqual(rd_instance.ServiceStatuses.SHUTDOWN, status)
def test_get_actual_db_status_error_crashed(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_get_actual_db_status_error_crashed(self, *args):
self.verticaAppStatus = VerticaAppStatus()
with patch.object(vertica_system, 'shell_execute',
MagicMock(side_effect=ProcessExecutionError('problem'
@ -3033,7 +3083,8 @@ class VerticaAppTest(testtools.TestCase):
enable_user_arguments.assert_called_with(
'some_password', expected_enable_user_cmd)
def test_enable_root_is_root_not_enabled_failed(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_enable_root_is_root_not_enabled_failed(self, *args):
app = VerticaApp(MagicMock())
with patch.object(app, 'read_config', return_value=self.test_config):
with patch.object(app, 'is_root_enabled', return_value=False):
@ -3042,7 +3093,8 @@ class VerticaAppTest(testtools.TestCase):
self.assertRaises(RuntimeError, app.enable_root,
'root_password')
def test_enable_root_is_root_enabled(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_enable_root_is_root_enabled(self, *args):
app = VerticaApp(MagicMock())
with patch.object(app, 'read_config', return_value=self.test_config):
with patch.object(app, 'is_root_enabled', return_value=True):
@ -3058,7 +3110,8 @@ class VerticaAppTest(testtools.TestCase):
alter_user_password_arguments.assert_called_with(
'some_password', expected_alter_user_cmd)
def test_enable_root_is_root_enabled_failed(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_enable_root_is_root_enabled_failed(self, *arg):
app = VerticaApp(MagicMock())
with patch.object(app, 'read_config', return_value=self.test_config):
with patch.object(app, 'is_root_enabled', return_value=True):
@ -3081,7 +3134,8 @@ class VerticaAppTest(testtools.TestCase):
user_exists_args.assert_called_with(expected_user_exists_cmd,
'dbadmin')
def test_is_root_enable_failed(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_is_root_enable_failed(self, *args):
app = VerticaApp(MagicMock())
with patch.object(app, 'read_config', return_value=self.test_config):
with patch.object(vertica_system, 'shell_execute',
@ -3113,7 +3167,8 @@ class VerticaAppTest(testtools.TestCase):
" -m vertica.local_coerce")
arguments.assert_called_with(expected_command)
def test_failure_prepare_for_install_vertica(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_failure_prepare_for_install_vertica(self, *args):
with patch.object(vertica_system, 'shell_execute',
side_effect=ProcessExecutionError('Error')):
self.assertRaises(ProcessExecutionError,
@ -3128,7 +3183,8 @@ class VerticaAppTest(testtools.TestCase):
vertica_system.INSTALL_VERTICA % ('10.0.0.2', '/var/lib/vertica'))
arguments.assert_called_with(expected_command)
def test_failure_install_vertica(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_failure_install_vertica(self, *args):
with patch.object(vertica_system, 'shell_execute',
side_effect=ProcessExecutionError('some exception')):
self.assertRaisesRegexp(RuntimeError, 'install_vertica failed.',
@ -3146,7 +3202,8 @@ class VerticaAppTest(testtools.TestCase):
'some_password'))
arguments.assert_called_with(expected_command, 'dbadmin')
def test_failure_create_db(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_failure_create_db(self, *args):
with patch.object(self.app, 'read_config',
side_effect=RuntimeError('Error')):
self.assertRaisesRegexp(RuntimeError,
@ -3301,7 +3358,8 @@ class VerticaAppTest(testtools.TestCase):
self.assertEqual(
2, vertica_system.shell_execute.call_count)
def test_stop_db_failure(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_stop_db_failure(self, *args):
mock_status = MagicMock()
type(mock_status)._is_restarting = PropertyMock(return_value=False)
app = VerticaApp(mock_status)
@ -3322,7 +3380,8 @@ class VerticaAppTest(testtools.TestCase):
self.app._export_conf_to_members(members=['member1', 'member2'])
self.assertEqual(2, vertica_system.shell_execute.call_count)
def test_fail__export_conf_to_members(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_fail__export_conf_to_members(self, *args):
app = VerticaApp(MagicMock())
with patch.object(vertica_system, 'shell_execute',
side_effect=ProcessExecutionError('Error')):
@ -3354,7 +3413,8 @@ class VerticaAppTest(testtools.TestCase):
vertica_system.shell_execute.assert_any_call(
'cat ' + '/home/' + user + '/.ssh/authorized_keys')
def test_fail_authorize_public_keys(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_fail_authorize_public_keys(self, *args):
user = 'test_user'
keys = ['test_key@machine1', 'test_key@machine2']
with patch.object(os.path, 'expanduser',
@ -3390,7 +3450,8 @@ class VerticaAppTest(testtools.TestCase):
self.assertEqual(2, vertica_system.shell_execute.call_count)
self.assertEqual('some_key', key)
def test_fail_get_public_keys(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_fail_get_public_keys(self, *args):
user = 'test_user'
with patch.object(os.path, 'expanduser',
return_value=('/home/' + user)):
@ -3426,7 +3487,8 @@ class VerticaAppTest(testtools.TestCase):
restart_policy.assert_called_with(expected_restart_policy)
agent_enable.assert_called_with(expected_agent_enable)
def test_failure__enable_db_on_boot(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_failure__enable_db_on_boot(self, *args):
with patch.object(subprocess, 'Popen', side_effect=OSError):
self.assertRaisesRegexp(RuntimeError,
'Could not enable db on boot.',
@ -3447,7 +3509,8 @@ class VerticaAppTest(testtools.TestCase):
restart_policy.assert_called_with(expected_restart_policy, 'dbadmin')
agent_disable.assert_called_with(expected_agent_disable, 'root')
def test_failure__disable_db_on_boot(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_failure__disable_db_on_boot(self, *args):
with patch.object(vertica_system, 'shell_execute',
side_effect=ProcessExecutionError('Error')):
self.assertRaisesRegexp(RuntimeError,
@ -3463,7 +3526,8 @@ class VerticaAppTest(testtools.TestCase):
test_config.get('credentials', 'dbadmin_password')
)
def test_fail_read_config(self):
@patch('trove.guestagent.datastore.experimental.vertica.service.LOG')
def test_fail_read_config(self, *args):
with patch.object(ConfigParser.ConfigParser, 'read',
side_effect=ConfigParser.Error()):
self.assertRaises(RuntimeError, self.app.read_config)
@ -3547,7 +3611,8 @@ class DB2AdminTest(testtools.TestCase):
db2service.utils.execute_with_timeout = (
self.orig_utils_execute_with_timeout)
def test_delete_database(self):
@patch('trove.guestagent.datastore.experimental.db2.service.LOG')
def test_delete_database(self, *args):
with patch.object(
db2service, 'run_command',
MagicMock(
@ -3562,7 +3627,8 @@ class DB2AdminTest(testtools.TestCase):
self.assertEqual(expected, args[0],
"Delete database queries are not the same")
def test_list_databases(self):
@patch('trove.guestagent.datastore.experimental.db2.service.LOG')
def test_list_databases(self, *args):
with patch.object(db2service, 'run_command', MagicMock(
side_effect=ProcessExecutionError('Error'))):
self.db2Admin.list_databases()

6
trove/tests/unittests/guestagent/test_mysql_manager.py
View File

@ -364,7 +364,8 @@ class GuestAgentManagerTest(testtools.TestCase):
# assertions
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
def test_attach_replication_slave_invalid(self):
@patch('trove.guestagent.datastore.mysql_common.manager.LOG')
def test_attach_replication_slave_invalid(self, *args):
mock_status = MagicMock()
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
@ -666,7 +667,8 @@ class GuestAgentManagerTest(testtools.TestCase):
# assertions
self.assertEqual(mock_replication.enable_as_master.call_count, 1)
def test__perform_restore(self):
@patch('trove.guestagent.datastore.mysql_common.manager.LOG')
def test__perform_restore(self, *args):
backup_info = {'id': 'backup_id_123abc',
'location': 'fake-location',
'type': 'InnoBackupEx',

3
trove/tests/unittests/guestagent/test_pkg.py
View File

@ -301,7 +301,8 @@ class PkgRPMVersionTestCase(trove_testtools.TestCase):
super(PkgRPMVersionTestCase, self).tearDown()
commands.getstatusoutput = self.commands_output
def test_version_no_output(self):
@patch('trove.guestagent.pkg.LOG')
def test_version_no_output(self, mock_logging):
cmd_out = ''
commands.getstatusoutput = Mock(return_value=(0, cmd_out))
self.assertIsNone(pkg.RedhatPackagerMixin().pkg_version(self.pkgName))

6
trove/tests/unittests/guestagent/test_pxc_api.py
View File

@ -49,12 +49,14 @@ class ApiTest(trove_testtools.TestCase):
self.assertEqual('guestagent.instance-id-x23d2d',
self.api._get_routing_key())
def test_api_cast_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_cast_exception(self, mock_logging):
self.call_context.cast.side_effect = IOError('host down')
self.assertRaises(exception.GuestError, self.api.create_user,
'test_user')
def test_api_call_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_call_exception(self, mock_logging):
self.call_context.call.side_effect = IOError('host_down')
self.assertRaises(exception.GuestError, self.api.list_users)

6
trove/tests/unittests/guestagent/test_vertica_api.py
View File

@ -49,12 +49,14 @@ class ApiTest(trove_testtools.TestCase):
self.assertEqual('guestagent.instance-id-x23d2d',
self.api._get_routing_key())
def test_api_cast_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_cast_exception(self, mock_logging):
self.call_context.cast.side_effect = IOError('host down')
self.assertRaises(exception.GuestError, self.api.create_user,
'test_user')
def test_api_call_exception(self):
@mock.patch('trove.guestagent.api.LOG')
def test_api_call_exception(self, mock_logging):
self.call_context.call.side_effect = IOError('host_down')
self.assertRaises(exception.GuestError, self.api.list_users)

8
trove/tests/unittests/guestagent/test_vertica_manager.py
View File

@ -170,7 +170,9 @@ class GuestAgentManagerTest(trove_testtools.TestCase):
@patch.object(VerticaAppStatus, 'set_status')
@patch.object(VerticaApp, 'install_cluster',
side_effect=RuntimeError("Boom!"))
def test_install_cluster_failure(self, mock_install, mock_set_status):
@patch('trove.guestagent.datastore.experimental.vertica.manager.LOG')
def test_install_cluster_failure(self, mock_logging,
mock_install, mock_set_status):
members = ["test1", "test2"]
self.assertRaises(RuntimeError, self.manager.install_cluster,
self.context, members)
@ -214,7 +216,9 @@ class GuestAgentManagerTest(trove_testtools.TestCase):
self.assertTrue(output)
@patch.object(VerticaAppStatus, 'set_status')
def test_prepare_invalid_cluster_config(self, mock_set_status):
@patch('trove.guestagent.datastore.manager.LOG')
def test_prepare_invalid_cluster_config(self, mock_logging,
mock_set_status):
self.assertRaises(RuntimeError,
self._prepare_method,
"test-instance-3", "query_router")

12
trove/tests/unittests/guestagent/test_volume.py
View File

@ -64,7 +64,8 @@ class VolumeDeviceTest(trove_testtools.TestCase):
self.assertEqual(1, utils.execute.call_count)
utils.execute = origin_execute
def test_fail__check_device_exists(self):
@patch('trove.guestagent.volume.LOG')
def test_fail__check_device_exists(self, mock_logging):
with patch.object(utils, 'execute', side_effect=ProcessExecutionError):
self.assertRaises(GuestError,
self.volumeDevice._check_device_exists)
@ -142,7 +143,8 @@ class VolumeDeviceTest(trove_testtools.TestCase):
@patch.object(os.path, 'ismount', return_value=True)
@patch.object(utils, 'execute', side_effect=ProcessExecutionError)
def test_fail_resize_fs(self, mock_execute, mock_mount):
@patch('trove.guestagent.volume.LOG')
def test_fail_resize_fs(self, mock_logging, mock_execute, mock_mount):
with patch.object(self.volumeDevice, '_check_device_exists'):
self.assertRaises(GuestError,
self.volumeDevice.resize_fs, '/mnt/volume')
@ -175,7 +177,8 @@ class VolumeDeviceTest(trove_testtools.TestCase):
self.assertEqual(['/var/lib/mysql'], mount_point)
@patch.object(utils, 'execute', side_effect=ProcessExecutionError)
def test_fail_mount_points(self, mock_execute):
@patch('trove.guestagent.volume.LOG')
def test_fail_mount_points(self, mock_logging, mock_execute):
self.assertRaises(GuestError, self.volumeDevice.mount_points,
'/mnt/volume')
@ -192,7 +195,8 @@ class VolumeDeviceTest(trove_testtools.TestCase):
readahead_size, "/dev/vdb")
self.volumeDevice._check_device_exists = origin_check_device_exists
def test_fail_set_readahead_size(self):
@patch('trove.guestagent.volume.LOG')
def test_fail_set_readahead_size(self, mock_logging):
mock_execute = MagicMock(side_effect=ProcessExecutionError)
readahead_size = 2048
with patch.object(self.volumeDevice, '_check_device_exists'):

6
trove/tests/unittests/instance/test_instance_models.py
View File

@ -257,7 +257,8 @@ class TestReplication(trove_testtools.TestCase):
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
def test_replica_of_not_active_master(self):
@patch('trove.instance.models.LOG')
def test_replica_of_not_active_master(self, mock_logging):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
@ -268,7 +269,8 @@ class TestReplication(trove_testtools.TestCase):
self.datastore_version, 1,
None, slave_of_id=self.master.id)
def test_replica_with_invalid_slave_of_id(self):
@patch('trove.instance.models.LOG')
def test_replica_with_invalid_slave_of_id(self, mock_logging):
self.assertRaises(exception.NotFound,
Instance.create,
None, 'name', 1, "UUID", [], [], None,

17
trove/tests/unittests/mgmt/test_models.py
View File

@ -121,7 +121,8 @@ class TestNotificationTransformer(MockMgmtInstanceTest):
def setUpClass(cls):
super(TestNotificationTransformer, cls).setUpClass()
def test_tranformer(self):
@patch('trove.instance.models.LOG')
def test_transformer(self, mock_logging):
status = rd_instance.ServiceStatuses.BUILDING.api_status
instance, service_status = self.build_db_instance(
status, InstanceTasks.BUILDING)
@ -144,7 +145,8 @@ class TestNotificationTransformer(MockMgmtInstanceTest):
self.assertThat(transformer._get_service_id('mysql', id_map),
Equals('123'))
def test_get_service_id_unknown(self):
@patch('trove.extensions.mgmt.instances.models.LOG')
def test_get_service_id_unknown(self, mock_logging):
id_map = {
'mysql': '123',
'percona': 'abc'
@ -182,7 +184,7 @@ class TestNovaNotificationTransformer(MockMgmtInstanceTest):
self.assertThat(transformer._lookup_flavor('2'),
Equals('unknown'))
def test_tranformer(self):
def test_transformer(self):
status = rd_instance.ServiceStatuses.BUILDING.api_status
instance, service_status = self.build_db_instance(
status, InstanceTasks.BUILDING)
@ -220,7 +222,8 @@ class TestNovaNotificationTransformer(MockMgmtInstanceTest):
self.assertThat(payload['service_id'], Equals('123'))
self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_invalid_datastore_manager(self):
@patch('trove.extensions.mgmt.instances.models.LOG')
def test_transformer_invalid_datastore_manager(self, mock_logging):
status = rd_instance.ServiceStatuses.BUILDING.api_status
instance, service_status = self.build_db_instance(
status, InstanceTasks.BUILDING)
@ -265,7 +268,7 @@ class TestNovaNotificationTransformer(MockMgmtInstanceTest):
version.update(manager='mysql')
self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_shutdown_instance(self):
def test_transformer_shutdown_instance(self):
status = rd_instance.ServiceStatuses.SHUTDOWN.api_status
instance, service_status = self.build_db_instance(status)
service_status.set_status(rd_instance.ServiceStatuses.SHUTDOWN)
@ -293,7 +296,7 @@ class TestNovaNotificationTransformer(MockMgmtInstanceTest):
for db in payloads])
self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_no_nova_instance(self):
def test_transformer_no_nova_instance(self):
status = rd_instance.ServiceStatuses.SHUTDOWN.api_status
instance, service_status = self.build_db_instance(status)
service_status.set_status(rd_instance.ServiceStatuses.SHUTDOWN)
@ -318,7 +321,7 @@ class TestNovaNotificationTransformer(MockMgmtInstanceTest):
for db in payloads])
self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_flavor_cache(self):
def test_transformer_flavor_cache(self):
status = rd_instance.ServiceStatuses.BUILDING.api_status
instance, service_status = self.build_db_instance(
status, InstanceTasks.BUILDING)

14
trove/tests/unittests/network/test_neutron_driver.py
View File

@ -15,7 +15,7 @@
#
from mock import MagicMock
from mock import Mock
from mock import Mock, patch
from neutronclient.common import exceptions as neutron_exceptions
from neutronclient.v2_0 import client as NeutronClient
@ -94,23 +94,27 @@ class NeutronDriverExceptionTest(trove_testtools.TestCase):
NeutronClient.Client = self.orig_NeutronClient
remote.get_endpoint = self.orig_get_endpoint
def test_create_sg_with_exception(self):
@patch('trove.network.neutron.LOG')
def test_create_sg_with_exception(self, mock_logging):
self.assertRaises(exception.SecurityGroupCreationError,
RemoteSecurityGroup.create,
"sg_name", "sg_desc", self.context)
def test_add_sg_rule_with_exception(self):
@patch('trove.network.neutron.LOG')
def test_add_sg_rule_with_exception(self, mock_logging):
self.assertRaises(exception.SecurityGroupRuleCreationError,
RemoteSecurityGroup.add_rule,
"12234", "tcp", "22", "22",
"0.0.0.0/8", self.context)
def test_delete_sg_rule_with_exception(self):
@patch('trove.network.neutron.LOG')
def test_delete_sg_rule_with_exception(self, mock_logging):
self.assertRaises(exception.SecurityGroupRuleDeletionError,
RemoteSecurityGroup.delete_rule,
"12234", self.context)
def test_delete_sg_with_exception(self):
@patch('trove.network.neutron.LOG')
def test_delete_sg_with_exception(self, mock_logging):
self.assertRaises(exception.SecurityGroupDeletionError,
RemoteSecurityGroup.delete,
"123445", self.context)

12
trove/tests/unittests/secgroups/test_security_group.py
View File

@ -61,24 +61,28 @@ class Security_Group_Exceptions_Test(trove_testtools.TestCase):
def _raise(self, ex):
raise ex
def test_failed_to_create_security_group(self):
@patch('trove.network.nova.LOG')
def test_failed_to_create_security_group(self, mock_logging):
self.assertRaises(exception.SecurityGroupCreationError,
sec_mod.RemoteSecurityGroup.create,
"TestName",
"TestDescription",
self.context)
def test_failed_to_delete_security_group(self):
@patch('trove.network.nova.LOG')
def test_failed_to_delete_security_group(self, mock_logging):
self.assertRaises(exception.SecurityGroupDeletionError,
sec_mod.RemoteSecurityGroup.delete,
1, self.context)
def test_failed_to_create_security_group_rule(self):
@patch('trove.network.nova.LOG')
def test_failed_to_create_security_group_rule(self, mock_logging):
self.assertRaises(exception.SecurityGroupRuleCreationError,
sec_mod.RemoteSecurityGroup.add_rule,
1, "tcp", 3306, 3306, "0.0.0.0/0", self.context)
def test_failed_to_delete_security_group_rule(self):
@patch('trove.network.nova.LOG')
def test_failed_to_delete_security_group_rule(self, mock_logging):
self.assertRaises(exception.SecurityGroupRuleDeletionError,
sec_mod.RemoteSecurityGroup.delete_rule,
1, self.context)

4
trove/tests/unittests/taskmanager/test_api.py
View File

@ -89,7 +89,9 @@ class ApiTest(trove_testtools.TestCase):
mock_heartbeat.delete.assert_called_with()
@patch.object(agent_models, 'AgentHeartBeat')
def test_exception_delete_heartbeat(self, mock_agent_heart_beat):
@patch('trove.taskmanager.api.LOG')
def test_exception_delete_heartbeat(self, mock_logging,
mock_agent_heart_beat):
mock_agent_heart_beat.return_value.find_by_instance_id.side_effect = (
exception.ModelNotFoundError)
self.api._delete_heartbeat('some-cluster-id')

23
trove/tests/unittests/taskmanager/test_clusters.py
View File

@ -96,7 +96,8 @@ class MongoDbClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'update_statuses_on_failure')
@patch.object(InstanceServiceStatus, 'find_by')
def test_all_instances_ready_bad_status(self,
@patch('trove.taskmanager.models.LOG')
def test_all_instances_ready_bad_status(self, mock_logging,
mock_find, mock_update):
(mock_find.return_value.
get_status.return_value) = ServiceStatuses.FAILED
@ -118,7 +119,9 @@ class MongoDbClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'get_ip')
@patch.object(datastore_models.Datastore, 'load')
@patch.object(datastore_models.DatastoreVersion, 'load_by_uuid')
def test_init_replica_set_failure(self, mock_dv, mock_ds,
@patch(
'trove.common.strategies.cluster.experimental.mongodb.taskmanager.LOG')
def test_init_replica_set_failure(self, mock_logging, mock_dv, mock_ds,
mock_ip, mock_guest,
mock_update):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
@ -169,8 +172,11 @@ class MongoDbClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'get_ip')
@patch.object(datastore_models.Datastore, 'load')
@patch.object(datastore_models.DatastoreVersion, 'load_by_uuid')
def test_create_shard_failure(self, mock_dv, mock_ds, mock_ip,
mock_guest, mock_init_rs, mock_update):
@patch(
'trove.common.strategies.cluster.experimental.mongodb.taskmanager.LOG')
def test_create_shard_failure(self, mock_logging, mock_dv, mock_ds,
mock_ip, mock_guest, mock_init_rs,
mock_update):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
@ -320,12 +326,11 @@ class MongoDbClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'get_cluster_admin_password')
@patch.object(datastore_models.Datastore, 'load')
@patch.object(datastore_models.DatastoreVersion, 'load_by_uuid')
@patch(
'trove.common.strategies.cluster.experimental.mongodb.taskmanager.LOG')
def test_add_query_routers_failure(self,
mock_dv,
mock_ds,
mock_password,
mock_guest,
mock_update):
mock_logging, mock_dv, mock_ds,
mock_password, mock_guest, mock_update):
query_router = BaseInstance(
Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW)

13
trove/tests/unittests/taskmanager/test_manager.py
View File

@ -125,6 +125,7 @@ class TestManager(trove_testtools.TestCase):
InstanceTasks.NONE)
@patch.object(Manager, '_set_task_status')
@patch('trove.taskmanager.manager.LOG')
def test_exception_TroveError_promote_to_replica_source(self, *args):
self.mock_slave2.detach_replica = Mock(side_effect=TroveError)
with patch.object(models.BuiltInstanceTasks, 'load',
@ -136,8 +137,10 @@ class TestManager(trove_testtools.TestCase):
@patch.object(Manager, '_set_task_status')
@patch.object(Manager, '_most_current_replica')
@patch('trove.taskmanager.manager.LOG')
def test_exception_TroveError_eject_replica_source(
self, mock_most_current_replica, mock_set_tast_status):
self, mock_logging, mock_most_current_replica,
mock_set_tast_status):
self.mock_slave2.detach_replica = Mock(side_effect=TroveError)
mock_most_current_replica.return_value = self.mock_slave1
with patch.object(models.BuiltInstanceTasks, 'load',
@ -159,7 +162,9 @@ class TestManager(trove_testtools.TestCase):
self.manager.promote_to_replica_source,
self.context, 'some-inst-id')
def test_error_demote_replication_master_promote_to_replica_source(self):
@patch('trove.taskmanager.manager.LOG')
def test_error_demote_replication_master_promote_to_replica_source(
self, mock_logging):
self.mock_old_master.demote_replication_master = Mock(
side_effect=RuntimeError('Error'))
@ -206,7 +211,9 @@ class TestManager(trove_testtools.TestCase):
@patch.object(models.FreshInstanceTasks, 'load')
@patch.object(Backup, 'delete')
def test_exception_create_replication_slave(self, mock_delete, mock_load):
@patch('trove.taskmanager.manager.LOG')
def test_exception_create_replication_slave(self, mock_logging,
mock_delete, mock_load):
mock_load.return_value.create_instance = Mock(side_effect=TroveError)
self.assertRaises(TroveError, self.manager.create_instance,
self.context, ['id1', 'id2'], Mock(), Mock(),

45
trove/tests/unittests/taskmanager/test_models.py
View File

@ -310,8 +310,9 @@ class FreshInstanceTasksTest(trove_testtools.TestCase):
return_value=fake_InstanceServiceStatus.find_by())
@patch.object(DBInstance, 'find_by',
return_value=fake_DBInstance.find_by())
@patch('trove.taskmanager.models.LOG')
def test_update_status_of_instance_failure(
self, dbi_find_by_mock, iss_find_by_mock):
self, mock_logging, dbi_find_by_mock, iss_find_by_mock):
self.task_models_conf_mock.get.return_value = ''
self.freshinstancetasks.update_statuses_on_time_out()
self.assertEqual(ServiceStatuses.FAILED_TIMEOUT_GUESTAGENT,
@ -365,7 +366,9 @@ class FreshInstanceTasksTest(trove_testtools.TestCase):
@patch.object(BaseInstance, 'update_db')
@patch('trove.taskmanager.models.CONF')
def test_error_sec_group_create_instance(self, mock_conf, mock_update_db):
@patch('trove.taskmanager.models.LOG')
def test_error_sec_group_create_instance(self, mock_logging,
mock_conf, mock_update_db):
mock_conf.get = Mock(
return_value=FakeOptGroup(tcp_ports=['3306', '-3306']))
mock_flavor = {'id': 7, 'ram': 256, 'name': 'smaller_flavor'}
@ -388,6 +391,7 @@ class FreshInstanceTasksTest(trove_testtools.TestCase):
@patch.object(template, 'OverrideConfigTemplate')
@patch.object(taskmanager_models.FreshInstanceTasks, '_create_dns_entry',
side_effect=TroveError)
@patch('trove.taskmanager.models.LOG')
def test_error_create_dns_entry_create_instance(self, *args):
mock_flavor = {'id': 6, 'ram': 512, 'name': 'big_flavor'}
self.assertRaisesRegexp(
@ -451,6 +455,7 @@ class FreshInstanceTasksTest(trove_testtools.TestCase):
'_render_replica_config')
@patch.object(trove.guestagent.api.API, 'attach_replication_slave',
side_effect=GuestError)
@patch('trove.taskmanager.models.LOG')
def test_error_attach_replication_slave(self, *args):
mock_flavor = {'id': 8, 'ram': 768, 'name': 'bigger_flavor'}
snapshot = {'replication_strategy': 'MysqlGTIDReplication',
@ -491,7 +496,8 @@ class ResizeVolumeTest(trove_testtools.TestCase):
def tearDown(self):
super(ResizeVolumeTest, self).tearDown()
def test_resize_volume_unmount_exception(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_volume_unmount_exception(self, mock_logging):
self.instance.guest.unmount_volume = Mock(
side_effect=GuestError("test exception"))
self.assertRaises(GuestError,
@ -501,7 +507,8 @@ class ResizeVolumeTest(trove_testtools.TestCase):
self.instance.guest.unmount_volume.side_effect = None
self.instance.reset_mock()
def test_resize_volume_detach_exception(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_volume_detach_exception(self, mock_logging):
self.instance.nova_client.volumes.delete_server_volume = Mock(
side_effect=nova_exceptions.ClientException("test exception"))
self.assertRaises(nova_exceptions.ClientException,
@ -513,7 +520,8 @@ class ResizeVolumeTest(trove_testtools.TestCase):
None)
self.instance.reset_mock()
def test_resize_volume_extend_exception(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_volume_extend_exception(self, mock_logging):
self.instance.volume_client.volumes.extend = Mock(
side_effect=cinder_exceptions.ClientException("test exception"))
self.assertRaises(cinder_exceptions.ClientException,
@ -527,14 +535,16 @@ class ResizeVolumeTest(trove_testtools.TestCase):
self.instance.volume_client.volumes.extend.side_effect = None
self.instance.reset_mock()
def test_resize_volume_verify_extend_no_volume(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_volume_verify_extend_no_volume(self, mock_logging):
self.instance.volume_client.volumes.get = Mock(
return_value=None)
self.assertRaises(cinder_exceptions.ClientException,
self.action._verify_extend)
self.instance.reset_mock()
def test_resize_volume_poll_timeout(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_volume_poll_timeout(self, mock_logging):
utils.poll_until = Mock(side_effect=PollTimeOut)
self.assertRaises(PollTimeOut, self.action._verify_extend)
self.assertEqual(2, self.instance.volume_client.volumes.get.call_count)
@ -718,7 +728,8 @@ class BuiltInstanceTasksTest(trove_testtools.TestCase):
self.assertEqual(1, self.stub_server_mgr.get.call_count)
self.assertThat(self.db_instance.flavor_id, Is(self.new_flavor['id']))
def test_resize_flavor_resize_failure(self):
@patch('trove.taskmanager.models.LOG')
def test_resize_flavor_resize_failure(self, mock_logging):
orig_server = self.instance_task.server
self.stub_verifying_server.status = 'ERROR'
with patch.object(self.instance_task._nova_client.servers, 'get',
@ -750,7 +761,8 @@ class BuiltInstanceTasksTest(trove_testtools.TestCase):
self.instance_task.set_datastore_status_to_paused.assert_any_call()
@patch.object(utils, 'poll_until')
def test_reboot_datastore_not_ready(self, mock_poll):
@patch('trove.taskmanager.models.LOG')
def test_reboot_datastore_not_ready(self, mock_logging, mock_poll):
self.instance_task.datastore_status_matches = Mock(return_value=False)
self.instance_task._refresh_datastore_status = Mock()
self.instance_task.server.reboot = Mock()
@ -767,7 +779,8 @@ class BuiltInstanceTasksTest(trove_testtools.TestCase):
self.instance_task._guest.detach_replica.assert_called_with(True)
mock_update_db.assert_called_with(slave_of_id=None)
def test_error_detach_replica(self):
@patch('trove.taskmanager.models.LOG')
def test_error_detach_replica(self, mock_logging):
with patch.object(self.instance_task._guest, 'detach_replica',
side_effect=GuestError):
self.assertRaises(GuestError, self.instance_task.detach_replica,
@ -799,7 +812,8 @@ class BuiltInstanceTasksTest(trove_testtools.TestCase):
replica_context, config_content)
mock_update_db.assert_called_with(slave_of_id=master.id)
def test_error_attach_replica(self):
@patch('trove.taskmanager.models.LOG')
def test_error_attach_replica(self, mock_logging):
with patch.object(self.instance_task._guest, 'attach_replica',
side_effect=GuestError):
self.assertRaises(GuestError, self.instance_task.attach_replica,
@ -913,7 +927,8 @@ class BackupTasksTest(trove_testtools.TestCase):
self.backup.id)
self.backup.delete.assert_any_call()
def test_delete_backup_fail_delete_manifest(self):
@patch('trove.taskmanager.models.LOG')
def test_delete_backup_fail_delete_manifest(self, mock_logging):
with patch.object(self.swift_client, 'delete_object',
side_effect=ClientException("foo")):
with patch.object(self.swift_client, 'head_object',
@ -928,7 +943,8 @@ class BackupTasksTest(trove_testtools.TestCase):
self.backup.state,
"backup should be in DELETE_FAILED status")
def test_delete_backup_fail_delete_segment(self):
@patch('trove.taskmanager.models.LOG')
def test_delete_backup_fail_delete_segment(self, mock_logging):
with patch.object(self.swift_client, 'delete_object',
side_effect=ClientException("foo")):
self.assertRaises(
@ -975,7 +991,8 @@ class NotifyMixinTest(trove_testtools.TestCase):
mixin = taskmanager_models.NotifyMixin()
self.assertThat(mixin._get_service_id('mysql', id_map), Equals('123'))
def test_get_service_id_unknown(self):
@patch('trove.taskmanager.models.LOG')
def test_get_service_id_unknown(self, mock_logging):
id_map = {
'mysql': '123',
'percona': 'abc'

8
trove/tests/unittests/taskmanager/test_pxc_clusters.py
View File

@ -85,7 +85,8 @@ class PXCClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'update_statuses_on_failure')
@patch.object(InstanceServiceStatus, 'find_by')
def test_all_instances_ready_bad_status(self,
@patch('trove.taskmanager.models.LOG')
def test_all_instances_ready_bad_status(self, mock_logging,
mock_find, mock_update):
(mock_find.return_value.
get_status.return_value) = ServiceStatuses.FAILED
@ -127,8 +128,9 @@ class PXCClusterTasksTest(trove_testtools.TestCase):
@patch.object(DBInstance, 'find_all')
@patch.object(datastore_models.Datastore, 'load')
@patch.object(datastore_models.DatastoreVersion, 'load_by_uuid')
def test_create_cluster_fail(self, mock_dv, mock_ds, mock_find_all,
mock_load, mock_ready, mock_ip,
@patch('trove.common.strategies.cluster.experimental.pxc.taskmanager.LOG')
def test_create_cluster_fail(self, mock_logging, mock_dv, mock_ds,
mock_find_all, mock_load, mock_ready, mock_ip,
mock_reset_task, mock_update_status):
mock_find_all.return_value.all.return_value = [self.dbinst1]
mock_load.return_value = BaseInstance(Mock(),

8
trove/tests/unittests/taskmanager/test_vertica_clusters.py
View File

@ -87,7 +87,8 @@ class VerticaClusterTasksTest(trove_testtools.TestCase):
@patch.object(ClusterTasks, 'update_statuses_on_failure')
@patch.object(InstanceServiceStatus, 'find_by')
def test_all_instances_ready_bad_status(self,
@patch('trove.taskmanager.models.LOG')
def test_all_instances_ready_bad_status(self, mock_logging,
mock_find, mock_update):
(mock_find.return_value.
get_status.return_value) = ServiceStatuses.FAILED
@ -151,7 +152,10 @@ class VerticaClusterTasksTest(trove_testtools.TestCase):
@patch.object(DBInstance, 'find_all')
@patch.object(datastore_models.Datastore, 'load')
@patch.object(datastore_models.DatastoreVersion, 'load_by_uuid')
def test_create_cluster_fail(self, mock_dv, mock_ds, mock_find_all,
@patch(
'trove.common.strategies.cluster.experimental.vertica.taskmanager.LOG')
def test_create_cluster_fail(self, mock_logging, mock_dv, mock_ds,
mock_find_all,
mock_load, mock_ready, mock_ip,
mock_reset_task, mock_update_status):
mock_find_all.return_value.all.return_value = [self.dbinst1]

11
trove/tests/unittests/trove_testtools.py
View File

@ -19,6 +19,8 @@ import os
import sys
import testtools
from trove.tests import root_logger
class TestCase(testtools.TestCase):
"""Base class of Trove unit tests.
@ -42,6 +44,7 @@ class TestCase(testtools.TestCase):
'TROVE_TESTS_UNMOCK_ONLY_UNIQUE', True))
cls._dangling_mocks = set()
root_logger.DefaultRootLogger()
@classmethod
def is_bool(cls, val):
@ -55,6 +58,14 @@ class TestCase(testtools.TestCase):
super(TestCase, self).setUp()
self.addCleanup(self._assert_modules_unmocked)
self._mocks_before = self._find_mock_refs()
root_logger.DefaultRootHandler.set_info(self.id())
def tearDown(self):
# yes, this is gross and not thread aware.
# but the only way to make it thread aware would require that
# we single thread all testing
root_logger.DefaultRootHandler.set_info(info=None)
super(TestCase, self).tearDown()
def _assert_modules_unmocked(self):
"""Check that all members of loaded modules are currently unmocked.