def test_assertInLogs_contains(self):
catcher = rally_logging.LogCatcher(self.logger)
record_mock = mock.MagicMock()
self.catcher_handler.return_value.buffer = [record_mock]
record_mock.msg.__contains__.return_value = True
self.assertEqual([record_mock.msg], catcher.assertInLogs("foo"))
record_mock.msg.__contains__.assert_called_once_with("foo")
def test_logcatcher(self):
LOG = rally_logging.getLogger("testlogger")
LOG.logger.setLevel(rally_logging.INFO)
with rally_logging.LogCatcher(LOG) as catcher:
LOG.warning("Warning")
LOG.info("Info")
LOG.debug("Debug")
catcher.assertInLogs("Warning")
self.assertRaises(AssertionError, catcher.assertInLogs, "Error")
self.assertEqual(["Warning", "Info"], catcher.fetchLogs())
self.assertEqual(2, len(catcher.fetchLogRecords()))
def test_boot_runcommand_delete(self):
with logging.LogCatcher(logging.LOG) as catcher:
self.scenario.boot_runcommand_delete(
"foo_image",
"foo_flavor",
script="foo_script",
interpreter="foo_interpreter",
username="******",
password="******",
use_floating_ip="use_fip",
floating_network="ext_network",
force_delete="foo_force",
volume_args={"size": 16},
foo_arg="foo_value")
catcher.assertInLogs(
"Use `command' argument instead (args `script', `interpreter' "
"deprecated in Rally v0.0.5)")
self.scenario._create_volume.assert_called_once_with(16, imageRef=None)
self.scenario._boot_server_with_fip.assert_called_once_with(
"foo_image",
"foo_flavor",
key_name="keypair_name",
use_floating_ip="use_fip",
floating_network="ext_network",
block_device_mapping={"vdrally": "foo_volume:::1"},
foo_arg="foo_value")
self.scenario._wait_for_ping.assert_called_once_with("foo_ip")
self.scenario._run_command.assert_called_once_with(
"foo_ip",
22,
"foo_username",
"foo_password",
command={
"script_file": "foo_script",
"interpreter": "foo_interpreter"
})
self.scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete="foo_force")
def test_exception_during_cleanup(self, quotas_ctxt, quotas_class_path):
quotas_path = "%s.%s" % (QUOTAS_PATH, quotas_class_path)
with mock.patch(quotas_path) as mock_quotas:
mock_quotas.return_value.update.side_effect = Exception
ctx = copy.deepcopy(self.context)
ctx["config"]["quotas"] = quotas_ctxt
quotas_instance = quotas.Quotas(ctx)
quotas_instance.original_quotas = []
for service in quotas_ctxt:
for tenant in self.context["tenants"]:
quotas_instance.original_quotas.append(
(service, tenant, quotas_ctxt[service]))
# NOTE(boris-42): ensure that cleanup didn't raise exceptions.
with logging.LogCatcher(quotas.LOG) as log:
quotas_instance.cleanup()
log.assertInLogs("Failed to restore quotas for tenant")
self.assertEqual(mock_quotas.return_value.update.call_count,
len(self.context["tenants"]))
def test_fetchLogs(self):
catcher = rally_logging.LogCatcher(self.logger)
self.assertEqual(
[r.msg for r in self.catcher_handler.return_value.buffer],
catcher.fetchLogs())
def test_fetchLogRecords(self):
catcher = rally_logging.LogCatcher(self.logger)
self.assertEqual(self.catcher_handler.return_value.buffer,
catcher.fetchLogRecords())
def test_assertInLogs(self):
catcher = rally_logging.LogCatcher(self.logger)
self.assertEqual(["foo"], catcher.assertInLogs("foo"))
self.assertEqual(["bar"], catcher.assertInLogs("bar"))
self.assertRaises(AssertionError, catcher.assertInLogs, "foobar")
def test_exit(self):
catcher = rally_logging.LogCatcher(self.logger)
catcher.__exit__(None, None, None)
self.logger.logger.removeHandler.assert_called_once_with(
self.catcher_handler.return_value)
def test_enter(self):
catcher = rally_logging.LogCatcher(self.logger)
self.assertEqual(catcher, catcher.__enter__())
self.logger.logger.addHandler.assert_called_once_with(
self.catcher_handler.return_value)
def test_init(self):
catcher = rally_logging.LogCatcher(self.logger)
self.assertEqual(self.logger.logger, catcher.logger)
self.assertEqual(self.catcher_handler.return_value, catcher.handler)
self.catcher_handler.assert_called_once_with()
