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

run_tests.py

@@ -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])

trove/tests/root_logger.py

@@ -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()

trove/tests/unittests/backup/test_backupagent.py

@@ -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(),

trove/tests/unittests/backup/test_storage.py

@@ -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

trove/tests/unittests/cluster/test_cluster.py

@@ -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,

trove/tests/unittests/cluster/test_pxc_cluster.py

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

trove/tests/unittests/cluster/test_redis_cluster.py

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

trove/tests/unittests/cluster/test_vertica_cluster.py

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

trove/tests/unittests/conductor/test_methods.py

@@ -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 ---
-
+    @patch('trove.conductor.manager.LOG')
-    def test_heartbeat_newer_timestamp_accepted(self):
+    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()

trove/tests/unittests/guestagent/test_agent_heartbeats_models.py

@@ -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
         """

trove/tests/unittests/guestagent/test_api.py

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

trove/tests/unittests/guestagent/test_couchbase_manager.py

@@ -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
 

trove/tests/unittests/guestagent/test_dbaas.py

@@ -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()

trove/tests/unittests/guestagent/test_mysql_manager.py

@@ -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',

trove/tests/unittests/guestagent/test_pkg.py

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

trove/tests/unittests/guestagent/test_pxc_api.py

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

trove/tests/unittests/guestagent/test_vertica_api.py

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

trove/tests/unittests/guestagent/test_vertica_manager.py

@@ -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")

trove/tests/unittests/guestagent/test_volume.py

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

trove/tests/unittests/instance/test_instance_models.py

@@ -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,

trove/tests/unittests/mgmt/test_models.py

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

trove/tests/unittests/network/test_neutron_driver.py

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

trove/tests/unittests/secgroups/test_security_group.py

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

trove/tests/unittests/taskmanager/test_api.py

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

trove/tests/unittests/taskmanager/test_clusters.py

@@ -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,
+    @patch(
-                                  mock_guest, mock_init_rs, mock_update):
+        '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_logging, mock_dv, mock_ds,
-                                       mock_ds,
+                                       mock_password, mock_guest, mock_update):
-                                       mock_password,
-                                       mock_guest,
-                                       mock_update):
         query_router = BaseInstance(
             Mock(), self.dbinst3, Mock(),
             InstanceServiceStatus(ServiceStatuses.NEW)

trove/tests/unittests/taskmanager/test_manager.py

@@ -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(),

trove/tests/unittests/taskmanager/test_models.py

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

trove/tests/unittests/taskmanager/test_pxc_clusters.py

@@ -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,
+    @patch('trove.common.strategies.cluster.experimental.pxc.taskmanager.LOG')
-                                 mock_load, mock_ready, mock_ip,
+    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(),

trove/tests/unittests/taskmanager/test_vertica_clusters.py

@@ -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]

trove/tests/unittests/trove_testtools.py

@@ -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.