def test_stack_webhook_invalid_output_key(self, mock_post):
scenario = utils.HeatScenario(self.context)
stack = mock.Mock()
stack.outputs = [{"output_key": "output1", "output_value": "url1"},
{"output_key": "output2", "output_value": "url2"}]
self.assertRaises(exceptions.InvalidConfigException,
scenario._stack_webhook, stack, "bogus")
def setUp(self):
super(HeatScenarioTestCase, self).setUp()
self.stack = mock.Mock()
self.scenario = utils.HeatScenario(self.context)
self.default_template = "heat_template_version: 2013-05-23"
self.dummy_parameters = {"dummy_param": "dummy_key"}
self.dummy_files = ["dummy_file.yaml"]
self.dummy_environment = {"dummy_env": "dummy_env_value"}
def test_list_stacks(self):
scenario = utils.HeatScenario(self.context)
return_stacks_list = scenario._list_stacks()
self.clients("heat").stacks.list.assert_called_once_with()
self.assertEqual(list(self.clients("heat").stacks.list.return_value),
return_stacks_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.list_stacks")
def test_stack_show_output_via_API(self):
scenario = utils.HeatScenario(self.context)
scenario._stack_show_output_via_API(self.stack,
self.default_output_key)
self.clients("heat").stacks.get.assert_called_once_with(
stack_id=self.stack.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.show_output_via_API")
def test__count_instances(self):
self.clients("heat").resources.list.return_value = [
mock.Mock(resource_type="OS::Nova::Server"),
mock.Mock(resource_type="OS::Nova::Server"),
mock.Mock(resource_type="OS::Heat::AutoScalingGroup")
]
scenario = utils.HeatScenario(self.context)
self.assertEqual(scenario._count_instances(self.stack), 2)
self.clients("heat").resources.list.assert_called_once_with(
self.stack.id, nested_depth=1)
def setup(self):
template = self._prepare_stack_template(
self.config["resources_per_stack"])
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
heat_scenario = heat_utils.HeatScenario({"user": user})
self.context["tenants"][tenant_id]["stacks"] = []
for i in range(self.config["stacks_per_tenant"]):
stack = heat_scenario._create_stack(template)
self.context["tenants"][tenant_id]["stacks"].append(stack.id)
def test_stack_webhook(self, mock_post):
scenario = utils.HeatScenario(self.context)
stack = mock.Mock(outputs=[
{"output_key": "output1", "output_value": "url1"},
{"output_key": "output2", "output_value": "url2"}])
scenario._stack_webhook(stack, "output1")
mock_post.assert_called_with("url1")
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.output1_webhook")
def test_failed_update_stack(self):
stack = mock.Mock()
resource = mock.Mock()
resource.stack_status = "UPDATE_FAILED"
stack.manager.get.return_value = resource
self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario(context=self.context)
ex = self.assertRaises(exceptions.GetResourceErrorStatus,
scenario._update_stack, stack,
"heat_template_version: 2013-05-23")
self.assertIn("has UPDATE_FAILED status", str(ex))
def test_delete_stack(self):
scenario = utils.HeatScenario()
scenario._delete_stack(self.stack)
self.stack.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with(
self.stack,
update_resource=self.gfm(),
check_interval=CONF.benchmark.heat_stack_delete_poll_interval,
timeout=CONF.benchmark.heat_stack_delete_timeout)
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.delete_stack")
def test_check_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._check_stack(self.stack)
self.clients("heat").actions.check.assert_called_once_with(
self.stack.id)
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
ready_statuses=["CHECK_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_check_poll_interval,
timeout=CONF.benchmark.heat_stack_check_timeout)
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.check_stack")
def test_failed_create_stack(self):
self.clients("heat").stacks.create.return_value = {
"stack": {"id": "test_id"}
}
stack = mock.Mock()
resource = mock.Mock()
resource.stack_status = "CREATE_FAILED"
stack.manager.get.return_value = resource
self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario(context=self.context)
ex = self.assertRaises(exceptions.GetResourceErrorStatus,
scenario._create_stack, "stack_name")
self.assertIn("has CREATE_FAILED status", str(ex))
def test_snapshot_stack(self):
scenario = utils.HeatScenario()
scenario._snapshot_stack(self.stack)
self.clients("heat").stacks.snapshot.assert_called_once_with(
self.stack.id)
self.wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.gfm(),
is_ready=self.res_is.mock(),
check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval,
timeout=CONF.benchmark.heat_stack_snapshot_timeout)
self.res_is.mock.assert_has_calls([mock.call("SNAPSHOT_COMPLETE")])
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.snapshot_stack")
def test_delete_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._delete_stack(self.stack)
self.stack.delete.assert_called_once_with()
self.mock_wait_for_status.mock.assert_called_once_with(
self.stack,
ready_statuses=["deleted"],
check_deletion=True,
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.heat_stack_delete_poll_interval,
timeout=CONF.benchmark.heat_stack_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.delete_stack")
def test_restore_stack(self):
scenario = utils.HeatScenario()
scenario._restore_stack(self.stack, "dummy_id")
self.clients("heat").stacks.restore.assert_called_once_with(
self.stack.id, "dummy_id")
self.wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.gfm(),
is_ready=self.res_is.mock(),
check_interval=CONF.benchmark.heat_stack_restore_poll_interval,
timeout=CONF.benchmark.heat_stack_restore_timeout)
self.res_is.mock.assert_has_calls([mock.call("RESTORE_COMPLETE")])
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.restore_stack")
def test_restore_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._restore_stack(self.stack, "dummy_id")
self.clients("heat").stacks.restore.assert_called_once_with(
self.stack.id, "dummy_id")
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
ready_statuses=["RESTORE_COMPLETE"],
failure_statuses=["RESTORE_FAILED"],
check_interval=CONF.benchmark.heat_stack_restore_poll_interval,
timeout=CONF.benchmark.heat_stack_restore_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.restore_stack")
def test_snapshot_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._snapshot_stack(self.stack)
self.clients("heat").stacks.snapshot.assert_called_once_with(
self.stack.id)
self.mock_wait_for_status.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
ready_statuses=["SNAPSHOT_COMPLETE"],
failure_statuses=["SNAPSHOT_FAILED", "ERROR"],
check_interval=CONF.openstack.heat_stack_snapshot_poll_interval,
timeout=CONF.openstack.heat_stack_snapshot_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.snapshot_stack")
def test_snapshot_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._snapshot_stack(self.stack)
self.clients("heat").stacks.snapshot.assert_called_once_with(
self.stack.id)
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval,
timeout=CONF.benchmark.heat_stack_snapshot_timeout)
self.mock_resource_is.mock.assert_called_once_with("SNAPSHOT_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["SNAPSHOT_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.snapshot_stack")
def setUp(self):
super(HeatScenarioTestCase, self).setUp()
self.stack = mock.Mock()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(HEAT_UTILS + ".bench_utils.wait_for")
self.wait_for_delete = mockpatch.Patch(HEAT_UTILS +
".bench_utils.wait_for_delete")
self.useFixture(self.wait_for)
self.useFixture(self.wait_for_delete)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
self.scenario = utils.HeatScenario()
self.default_template = "heat_template_version: 2013-05-23"
self.dummy_parameters = {"dummy_param": "dummy_key"}
self.dummy_files = ["dummy_file.yaml"]
self.dummy_environment = {"dummy_env": "dummy_env_value"}
def test__scale_stack(self):
scenario = utils.HeatScenario(self.context)
scenario._count_instances = mock.Mock(side_effect=[3, 3, 2])
scenario._stack_webhook = mock.Mock()
scenario._scale_stack(self.stack, "test_output_key", -1)
scenario._stack_webhook.assert_called_once_with(
self.stack, "test_output_key")
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
is_ready=mock.ANY,
failure_statuses=["UPDATE_FAILED"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.heat_stack_scale_timeout,
check_interval=CONF.benchmark.heat_stack_scale_poll_interval)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.scale_with_test_output_key")
def test_update_stack(self):
self.clients("heat").stacks.update.return_value = None
scenario = utils.HeatScenario()
scenario._update_stack(self.stack, self.default_template,
self.dummy_parameters, self.dummy_files,
self.dummy_environment)
args, kwargs = self.clients("heat").stacks.update.call_args
self.assertIn(self.dummy_parameters, kwargs.values())
self.assertIn(self.default_template, kwargs.values())
self.assertIn(self.dummy_files, kwargs.values())
self.assertIn(self.dummy_environment, kwargs.values())
self.assertIn(self.stack.id, args)
self.wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.gfm(),
is_ready=self.res_is.mock(),
check_interval=CONF.benchmark.heat_stack_update_poll_interval,
timeout=CONF.benchmark.heat_stack_update_timeout)
self.res_is.mock.assert_has_calls([mock.call("UPDATE_COMPLETE")])
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.update_stack")
def test_update_stack(self):
self.clients("heat").stacks.update.return_value = None
scenario = utils.HeatScenario(self.context)
scenario._update_stack(self.stack, self.default_template,
self.dummy_parameters, self.dummy_files,
self.dummy_environment)
args, kwargs = self.clients("heat").stacks.update.call_args
self.assertIn(self.dummy_parameters, kwargs.values())
self.assertIn(self.default_template, kwargs.values())
self.assertIn(self.dummy_files, kwargs.values())
self.assertIn(self.dummy_environment, kwargs.values())
self.assertIn(self.stack.id, args)
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
ready_statuses=["UPDATE_COMPLETE"],
failure_statuses=["UPDATE_FAILED"],
check_interval=CONF.benchmark.heat_stack_update_poll_interval,
timeout=CONF.benchmark.heat_stack_update_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.update_stack")
def setup(self):
template = get_data(self.config["template"])
files = {}
for key, filename in self.config.get("files", {}).items():
files[key] = get_data(filename)
parameters = self.config.get("parameters", rutils.LockedDict())
with parameters.unlocked():
if "network_id" not in parameters:
parameters["network_id"] = self._get_public_network_id()
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
for name, path in self.config.get("context_parameters",
{}).items():
parameters[name] = self._get_context_parameter(
user, tenant_id, path)
if "router_id" not in parameters:
networks = self.context["tenants"][tenant_id]["networks"]
parameters["router_id"] = networks[0]["router_id"]
if "key_name" not in parameters:
parameters["key_name"] = user["keypair"]["name"]
heat_scenario = heat_utils.HeatScenario({
"user":
user,
"task":
self.context["task"],
"owner_id":
self.context["owner_id"]
})
self.context["tenants"][tenant_id]["stack_dataplane"] = []
for i in range(self.config["stacks_per_tenant"]):
stack = heat_scenario._create_stack(template,
files=files,
parameters=parameters)
tenant_data = self.context["tenants"][tenant_id]
tenant_data["stack_dataplane"].append(
[stack.id, template, files, parameters])
