From 9305478141502f5eec289b30c9363731a699948c Mon Sep 17 00:00:00 2001 From: Rabi Mishra Date: Thu, 28 Jan 2016 10:08:57 +0530 Subject: [PATCH] Resolve name/id using translation rules for Server This changes OS::Nova::Server resource to use translation rules to resolve name_id properties. As most of the tests in test_server.py and test_rackspace_cloud_server.py are impacted by this change, this also changes all the tests to use mock library. Though the change is very big, it's mostly mox to mock conversion for the tests. This reduces the LOC drastically. Some of these test modules have become very big to manage. We can split them into smaller ones in the future. Change-Id: Iaa630ab3b013dfb65e9131b1f265e846c8274037 Partial-Bug: #1514680 Blueprint: mox-to-mock-conversion --- .../tests/test_rackspace_cloud_server.py | 130 +- heat/engine/clients/os/nova.py | 2 +- heat/engine/resources/aws/ec2/instance.py | 2 +- .../engine/resources/openstack/nova/server.py | 78 +- .../openstack/nova/server_network_mixin.py | 23 +- heat/tests/aws/test_instance.py | 20 +- .../tests/engine/service/test_stack_update.py | 11 +- heat/tests/openstack/nova/test_server.py | 2105 +++++------------ heat/tests/test_metadata_refresh.py | 25 +- 9 files changed, 781 insertions(+), 1615 deletions(-) diff --git a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py index 810fab554e..d7f1828a02 100644 --- a/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py +++ b/contrib/rackspace/rackspace/tests/test_rackspace_cloud_server.py @@ -12,13 +12,15 @@ # under the License. import mock -import mox from oslo_config import cfg from oslo_utils import uuidutils import six from heat.common import exception from heat.common import template_format +from heat.engine.clients.os import glance +from heat.engine.clients.os import neutron +from heat.engine.clients.os import nova from heat.engine import environment from heat.engine import resource from heat.engine import rsrc_defn @@ -77,16 +79,6 @@ class CloudServersTest(common.HeatTestCase): resource._register_class("OS::Nova::Server", cloud_server.CloudServer) - def _mock_find_image_by_name_or_id_success(self, imageId): - self.mock_get_image = mock.Mock() - self.ctx.clients.client_plugin( - 'glance').find_image_by_name_or_id = self.mock_get_image - self.mock_get_image.return_value = imageId - - def _stub_server_validate(self, server, imageId_input, image_id): - # stub glance image validate - self._mock_find_image_by_name_or_id_success(image_id) - def _setup_test_stack(self, stack_name): t = template_format.parse(wp_template) templ = template.Template( @@ -97,7 +89,7 @@ class CloudServersTest(common.HeatTestCase): return (templ, self.stack) def _setup_test_server(self, return_server, name, image_id=None, - override_name=False, stub_create=True, exit_code=0): + override_name=False, stub_create=True): stack_name = '%s_s' % name (tmpl, stack) = self._setup_test_stack(stack_name) @@ -105,7 +97,13 @@ class CloudServersTest(common.HeatTestCase): 'image'] = image_id or 'CentOS 5.2' tmpl.t['Resources']['WebServer']['Properties'][ 'flavor'] = '256 MB Server' - + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id', + return_value='aaaaaa') + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + return_value=1) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) server_name = '%s' % name if override_name: tmpl.t['Resources']['WebServer']['Properties'][ @@ -115,41 +113,23 @@ class CloudServersTest(common.HeatTestCase): server = cloud_server.CloudServer(server_name, resource_defns['WebServer'], stack) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + self.patchobject(server, 'store_external_ports') - self._stub_server_validate(server, image_id or 'CentOS 5.2', 1) if stub_create: - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=1, - flavor=1, - key_name='test', - name=override_name and server.name or utils.PhysName( - stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), - scheduler_hints=None, - meta=None, - nics=None, - availability_zone=None, - block_device_mapping=None, - block_device_mapping_v2=None, - config_drive=True, - disk_config=None, - reservation_id=None, - files=mox.IgnoreArg(), - admin_pass=None).AndReturn(return_server) - + self.patchobject(self.fc.servers, 'create', + return_value=return_server) + # mock check_create_complete innards + self.patchobject(self.fc.servers, 'get', + return_value=return_server) return server def _create_test_server(self, return_server, name, override_name=False, - stub_create=True, exit_code=0): + stub_create=True): server = self._setup_test_server(return_server, name, - stub_create=stub_create, - exit_code=exit_code) - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.id).AndReturn(return_server) - self.m.ReplayAll() + stub_create=stub_create) scheduler.TaskRunner(server.create)() return server @@ -166,14 +146,9 @@ class CloudServersTest(common.HeatTestCase): server = self._setup_test_server(return_server, 'test_rackconnect_deployed') server.context.roles = ['rack_connect'] - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) - self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual('CREATE', server.action) self.assertEqual('COMPLETE', server.status) - self.m.VerifyAll() def test_rackconnect_failed(self): return_server = self.fc.servers.list()[1] @@ -181,13 +156,9 @@ class CloudServersTest(common.HeatTestCase): 'rackconnect_automation_status': 'FAILED', 'rax_service_level_automation': 'Complete', } - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) server = self._setup_test_server(return_server, 'test_rackconnect_failed') server.context.roles = ['rack_connect'] - self.m.ReplayAll() create = scheduler.TaskRunner(server.create) exc = self.assertRaises(exception.ResourceFailure, create) self.assertEqual('Error: resources.test_rackconnect_failed: ' @@ -201,17 +172,12 @@ class CloudServersTest(common.HeatTestCase): 'rackconnect_unprocessable_reason': 'Fake reason', 'rax_service_level_automation': 'Complete', } - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) server = self._setup_test_server(return_server, 'test_rackconnect_unprocessable') server.context.roles = ['rack_connect'] - self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual('CREATE', server.action) self.assertEqual('COMPLETE', server.status) - self.m.VerifyAll() def test_rackconnect_unknown(self): return_server = self.fc.servers.list()[1] @@ -219,13 +185,9 @@ class CloudServersTest(common.HeatTestCase): 'rackconnect_automation_status': 'FOO', 'rax_service_level_automation': 'Complete', } - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) server = self._setup_test_server(return_server, 'test_rackconnect_unknown') server.context.roles = ['rack_connect'] - self.m.ReplayAll() create = scheduler.TaskRunner(server.create) exc = self.assertRaises(exception.ResourceFailure, create) self.assertEqual('Error: resources.test_rackconnect_unknown: ' @@ -257,13 +219,10 @@ class CloudServersTest(common.HeatTestCase): return return_server self.patchobject(self.fc.servers, 'get', side_effect=activate_status) - self.m.ReplayAll() scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_rackconnect_no_status(self): return_server = self.fc.servers.list()[0] server = self._setup_test_server(return_server, @@ -287,13 +246,9 @@ class CloudServersTest(common.HeatTestCase): return return_server self.patchobject(self.fc.servers, 'get', side_effect=activate_status) - self.m.ReplayAll() - scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_rax_automation_lifecycle(self): return_server = self.fc.servers.list()[0] server = self._setup_test_server(return_server, @@ -322,19 +277,19 @@ class CloudServersTest(common.HeatTestCase): return return_server self.patchobject(self.fc.servers, 'get', side_effect=activate_status) - self.m.ReplayAll() - scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_add_port_for_addresses(self): return_server = self.fc.servers.list()[1] return_server.metadata = {'rax_service_level_automation': 'Complete'} stack_name = 'test_stack' (tmpl, stack) = self._setup_test_stack(stack_name) resource_defns = tmpl.resource_definitions(stack) + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + return_value=1) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) server = cloud_server.CloudServer('WebServer', resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') @@ -432,10 +387,6 @@ class CloudServersTest(common.HeatTestCase): 'Build Error'} server = self._setup_test_server(return_server, 'test_managed_cloud_build_error') - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) - self.m.ReplayAll() create = scheduler.TaskRunner(server.create) exc = self.assertRaises(exception.ResourceFailure, create) self.assertEqual('Error: resources.test_managed_cloud_build_error: ' @@ -447,10 +398,6 @@ class CloudServersTest(common.HeatTestCase): return_server.metadata = {'rax_service_level_automation': 'FOO'} server = self._setup_test_server(return_server, 'test_managed_cloud_unknown') - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) - self.m.ReplayAll() create = scheduler.TaskRunner(server.create) exc = self.assertRaises(exception.ResourceFailure, create) self.assertEqual('Error: resources.test_managed_cloud_unknown: ' @@ -462,6 +409,10 @@ class CloudServersTest(common.HeatTestCase): return_server = self.fc.servers.list()[1] return_server.metadata = {'rax_service_level_automation': 'Complete'} stack_name = 'no_user_data' + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + return_value=1) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) (tmpl, stack) = self._setup_test_stack(stack_name) properties = tmpl.t['Resources']['WebServer']['Properties'] properties['user_data'] = user_data @@ -476,15 +427,11 @@ class CloudServersTest(common.HeatTestCase): self.patchobject(server, "_populate_deployments_metadata") mock_servers_create = mock.Mock(return_value=return_server) self.fc.servers.create = mock_servers_create - image_id = mock.ANY - self._mock_find_image_by_name_or_id_success(image_id) - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).MultipleTimes( - ).AndReturn(return_server) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + return_value=return_server) scheduler.TaskRunner(server.create)() mock_servers_create.assert_called_with( - image=image_id, + image=mock.ANY, flavor=mock.ANY, key_name=mock.ANY, name=mock.ANY, @@ -543,15 +490,14 @@ class CloudServersValidationTests(common.HeatTestCase): "key_name": "test", "user_data": "wordpress", } + rsrcdef = rsrc_defn.ResourceDefinition( "test", cloud_server.CloudServer, properties=properties_server) - + mock_plugin().find_flavor_by_name_or_id.return_value = 1 server = cloud_server.CloudServer("test", rsrcdef, self.mockstack) - mock_boot_vol = self.patchobject( server, '_validate_block_device_mapping') mock_boot_vol.return_value = True - self.assertIsNone(server.validate()) def test_validate_no_image_bfv(self, mock_client, mock_plugin): @@ -563,6 +509,7 @@ class CloudServersValidationTests(common.HeatTestCase): rsrcdef = rsrc_defn.ResourceDefinition( "test", cloud_server.CloudServer, properties=properties_server) + mock_plugin().find_flavor_by_name_or_id.return_value = 1 server = cloud_server.CloudServer("test", rsrcdef, self.mockstack) mock_boot_vol = self.patchobject( @@ -577,7 +524,6 @@ class CloudServersValidationTests(common.HeatTestCase): } mock_plugin().get_flavor.return_value = mock_flavor - error = self.assertRaises( exception.StackValidationFailed, server.validate) self.assertEqual( @@ -585,6 +531,8 @@ class CloudServersValidationTests(common.HeatTestCase): six.text_type(error)) def test_validate_bfv_volume_only(self, mock_client, mock_plugin): + mock_plugin().find_flavor_by_name_or_id.return_value = 1 + mock_plugin().find_image_by_name_or_id.return_value = 1 server = cloud_server.CloudServer("test", self.rsrcdef, self.mockstack) mock_flavor = mock.Mock(ram=4, disk=4) @@ -609,6 +557,8 @@ class CloudServersValidationTests(common.HeatTestCase): def test_validate_image_flavor_excluded_class(self, mock_client, mock_plugin): + mock_plugin().find_flavor_by_name_or_id.return_value = 1 + mock_plugin().find_image_by_name_or_id.return_value = 1 server = cloud_server.CloudServer("test", self.rsrcdef, self.mockstack) mock_image = mock.Mock(status='ACTIVE', min_ram=2, min_disk=1) @@ -631,6 +581,8 @@ class CloudServersValidationTests(common.HeatTestCase): six.text_type(error)) def test_validate_image_flavor_ok(self, mock_client, mock_plugin): + mock_plugin().find_flavor_by_name_or_id.return_value = 1 + mock_plugin().find_image_by_name_or_id.return_value = 1 server = cloud_server.CloudServer("test", self.rsrcdef, self.mockstack) mock_image = mock.Mock(size=1, status='ACTIVE', min_ram=2, min_disk=2) diff --git a/heat/engine/clients/os/nova.py b/heat/engine/clients/os/nova.py index f254e1c629..9d60c1c498 100644 --- a/heat/engine/clients/os/nova.py +++ b/heat/engine/clients/os/nova.py @@ -450,7 +450,7 @@ echo -e '%s\tALL=(ALL)\tNOPASSWD: ALL' >> /etc/sudoers else: return False - def check_resize(self, server_id, flavor_id, flavor): + def check_resize(self, server_id, flavor): """Verify that a resizing server is properly resized. If that's the case, confirm the resize, if not raise an error. diff --git a/heat/engine/resources/aws/ec2/instance.py b/heat/engine/resources/aws/ec2/instance.py index 2d28d151e1..3025019e1a 100644 --- a/heat/engine/resources/aws/ec2/instance.py +++ b/heat/engine/resources/aws/ec2/instance.py @@ -630,7 +630,7 @@ class Instance(resource.Resource, sh.SchedulerHintsMixin): flavor = prop_diff[self.INSTANCE_TYPE] flavor_id = self.client_plugin().find_flavor_by_name_or_id(flavor) handler_args = {'args': (flavor_id,)} - checker_args = {'args': (flavor_id, flavor)} + checker_args = {'args': (flavor_id,)} prg_resize = progress.ServerUpdateProgress(self.resource_id, 'resize', diff --git a/heat/engine/resources/openstack/nova/server.py b/heat/engine/resources/openstack/nova/server.py index 413221b70a..6a1473b634 100644 --- a/heat/engine/resources/openstack/nova/server.py +++ b/heat/engine/resources/openstack/nova/server.py @@ -567,11 +567,57 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, entity = 'servers' def translation_rules(self, props): - return [translation.TranslationRule( - props, - translation.TranslationRule.REPLACE, - source_path=[self.NETWORKS, self.NETWORK_ID], - value_name=self.NETWORK_UUID)] + rules = [ + translation.TranslationRule( + props, + translation.TranslationRule.REPLACE, + source_path=[self.NETWORKS, self.NETWORK_ID], + value_name=self.NETWORK_UUID), + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.FLAVOR], + client_plugin=self.client_plugin('nova'), + finder='find_flavor_by_name_or_id'), + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.IMAGE], + client_plugin=self.client_plugin('glance'), + finder='find_image_by_name_or_id'), + ] + if self.is_using_neutron(): + rules.extend([ + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.NETWORKS, self.NETWORK_ID], + client_plugin=self.client_plugin('neutron'), + finder='find_resourceid_by_name_or_id', + entity='network'), + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.NETWORKS, self.NETWORK_SUBNET], + client_plugin=self.client_plugin('neutron'), + finder='find_resourceid_by_name_or_id', + entity='subnet'), + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.NETWORKS, self.NETWORK_PORT], + client_plugin=self.client_plugin('neutron'), + finder='find_resourceid_by_name_or_id', + entity='port')]) + else: + rules.extend([ + translation.TranslationRule( + props, + translation.TranslationRule.RESOLVE, + source_path=[self.NETWORKS, self.NETWORK_ID], + client_plugin=self.client_plugin('nova'), + finder='get_nova_network_id')]) + return rules def __init__(self, name, json_snippet, stack): super(Server, self).__init__(name, json_snippet, stack) @@ -771,16 +817,7 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, instance_user=None, user_data_format=user_data_format) - flavor = self.properties[self.FLAVOR] availability_zone = self.properties[self.AVAILABILITY_ZONE] - - image = self.properties[self.IMAGE] - if image: - image = self.client_plugin( - 'glance').find_image_by_name_or_id(image) - - flavor_id = self.client_plugin().find_flavor_by_name_or_id(flavor) - instance_meta = self.properties[self.METADATA] if instance_meta is not None: instance_meta = self.client_plugin().meta_serialize( @@ -799,13 +836,15 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, admin_pass = self.properties[self.ADMIN_PASS] or None personality_files = self.properties[self.PERSONALITY] key_name = self.properties[self.KEY_NAME] + flavor = self.properties[self.FLAVOR] + image = self.properties[self.IMAGE] server = None try: server = self.client().servers.create( name=self._server_name(), image=image, - flavor=flavor_id, + flavor=flavor, key_name=key_name, security_groups=security_groups, userdata=userdata, @@ -1028,10 +1067,7 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, def _update_flavor(self, prop_diff): flavor = prop_diff[self.FLAVOR] - flavor_id = self.client_plugin().find_flavor_by_name_or_id(flavor) - handler_args = {'args': (flavor_id,)} - checker_args = {'args': (flavor_id, flavor)} - + handler_args = checker_args = {'args': (flavor,)} prg_resize = progress.ServerUpdateProgress(self.resource_id, 'resize', handler_extra=handler_args, @@ -1045,8 +1081,6 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, prop_diff.get(self.IMAGE_UPDATE_POLICY) or self.properties[self.IMAGE_UPDATE_POLICY]) image = prop_diff[self.IMAGE] - image_id = self.client_plugin( - 'glance').find_image_by_name_or_id(image) preserve_ephemeral = ( image_update_policy == 'REBUILD_PRESERVE_EPHEMERAL') password = (prop_diff.get(self.ADMIN_PASS) or @@ -1055,7 +1089,7 @@ class Server(stack_user.StackUser, sh.SchedulerHintsMixin, 'preserve_ephemeral': preserve_ephemeral} prg = progress.ServerUpdateProgress(self.resource_id, 'rebuild', - handler_extra={'args': (image_id,), + handler_extra={'args': (image,), 'kwargs': kwargs}) return prg diff --git a/heat/engine/resources/openstack/nova/server_network_mixin.py b/heat/engine/resources/openstack/nova/server_network_mixin.py index fd3bd369fa..f155798731 100644 --- a/heat/engine/resources/openstack/nova/server_network_mixin.py +++ b/heat/engine/resources/openstack/nova/server_network_mixin.py @@ -66,8 +66,7 @@ class ServerNetworkMixin(object): subnet = network.get(self.NETWORK_SUBNET) if (subnet is not None and net is not None): subnet_net = self.client_plugin( - 'neutron').network_id_from_subnet_id( - self._get_subnet_id(subnet)) + 'neutron').network_id_from_subnet_id(subnet) if subnet_net != net: msg = _('Specified subnet %(subnet)s does not belongs to ' 'network %(network)s.') % { @@ -98,7 +97,7 @@ class ServerNetworkMixin(object): if fixed_ip: body['ip_address'] = fixed_ip if subnet: - body['subnet_id'] = self._get_subnet_id(subnet) + body['subnet_id'] = subnet # we should add fixed_ips only if subnet or ip were provided if body: kwargs.update({'fixed_ips': [body]}) @@ -276,23 +275,11 @@ class ServerNetworkMixin(object): def _get_network_id(self, net): net_id = net.get(self.NETWORK_ID) or None subnet = net.get(self.NETWORK_SUBNET) or None - if net_id: - if self.is_using_neutron(): - net_id = self.client_plugin( - 'neutron').find_resourceid_by_name_or_id('network', - net_id) - else: - net_id = self.client_plugin( - 'nova').get_nova_network_id(net_id) - elif subnet: - net_id = self.client_plugin('neutron').network_id_from_subnet_id( - self._get_subnet_id(subnet)) + if not net_id and subnet: + net_id = self.client_plugin( + 'neutron').network_id_from_subnet_id(subnet) return net_id - def _get_subnet_id(self, subnet): - return self.client_plugin('neutron').find_resourceid_by_name_or_id( - 'subnet', subnet) - def update_networks_matching_iface_port(self, nets, interfaces): def find_equal(port, net_id, ip, nets): diff --git a/heat/tests/aws/test_instance.py b/heat/tests/aws/test_instance.py index e742f5ab9a..79cb716d7f 100644 --- a/heat/tests/aws/test_instance.py +++ b/heat/tests/aws/test_instance.py @@ -722,10 +722,17 @@ class InstancesTest(common.HeatTestCase): instance = self._create_test_instance(return_server, 'ud_type') - self._stub_glance_for_update() update_template = copy.deepcopy(instance.t) update_template['Properties']['InstanceType'] = 'm1.small' + def side_effect(*args): + return 2 if args[0] == 'm1.small' else 1 + + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + side_effect=side_effect) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) + self.m.StubOutWithMock(self.fc.servers, 'get') def status_resize(*args): @@ -770,7 +777,14 @@ class InstancesTest(common.HeatTestCase): instance = self._create_test_instance(return_server, 'ud_type_f') - self._stub_glance_for_update() + def side_effect(*args): + return 2 if args[0] == 'm1.small' else 1 + + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + side_effect=side_effect) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) + update_template = copy.deepcopy(instance.t) update_template['Properties']['InstanceType'] = 'm1.small' @@ -797,7 +811,7 @@ class InstancesTest(common.HeatTestCase): error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( "Error: resources.ud_type_f: " - "Resizing to 'm1.small' failed, status 'ERROR'", + "Resizing to '2' failed, status 'ERROR'", six.text_type(error)) self.assertEqual((instance.UPDATE, instance.FAILED), instance.state) self.m.VerifyAll() diff --git a/heat/tests/engine/service/test_stack_update.py b/heat/tests/engine/service/test_stack_update.py index 1a14e5eb70..e33cd6ce94 100644 --- a/heat/tests/engine/service/test_stack_update.py +++ b/heat/tests/engine/service/test_stack_update.py @@ -21,6 +21,8 @@ import six from heat.common import exception from heat.common import messaging from heat.common import template_format +from heat.engine.clients.os import glance +from heat.engine.clients.os import nova from heat.engine import environment from heat.engine import resource from heat.engine import service @@ -853,6 +855,14 @@ resources: environment_files=None): stack_name = 'service_update_test_stack_preview' params = {'foo': 'bar'} + + def side_effect(*args): + return 2 if args[0] == 'm1.small' else 1 + + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + side_effect=side_effect) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) old_stack = tools.get_stack(stack_name, self.ctx, template=orig_template) sid = old_stack.store() @@ -947,7 +957,6 @@ resources: def test_stack_update_preview_updated(self): # new template changes to flavor of server new_tmpl = self.old_tmpl.replace('m1.large', 'm1.small') - result = self._test_stack_update_preview(self.old_tmpl, new_tmpl) updated = [x for x in result['updated']][0] diff --git a/heat/tests/openstack/nova/test_server.py b/heat/tests/openstack/nova/test_server.py index 34ef82b793..369c7b4970 100644 --- a/heat/tests/openstack/nova/test_server.py +++ b/heat/tests/openstack/nova/test_server.py @@ -15,8 +15,6 @@ import collections import copy import mock -import mox -from neutronclient.neutron import v2_0 as neutronV20 from neutronclient.v2_0 import client as neutronclient from novaclient import exceptions as nova_exceptions from oslo_serialization import jsonutils @@ -61,7 +59,7 @@ wp_template = ''' "WebServer": { "Type": "OS::Nova::Server", "Properties": { - "image" : "F17-x86_64-gold", + "image" : "F18-x86_64-gold", "flavor" : "m1.large", "key_name" : "test", "user_data" : "wordpress" @@ -92,11 +90,11 @@ resources: image: F17-x86_64-gold flavor: m1.large networks: - - { uuid: 12345 } + - { uuid: 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' } subnet: type: OS::Neutron::Subnet properties: - network: 12345 + network: 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' ''' no_subnet_template = ''' @@ -152,6 +150,17 @@ class ServersTest(common.HeatTestCase): self.mock_flavor = mock.Mock(ram=4, disk=4) self.mock_image = mock.Mock(min_ram=1, min_disk=1, status='active') + def flavor_side_effect(*args): + return 2 if args[0] == 'm1.small' else 1 + + def image_side_effect(*args): + return 2 if args[0] == 'F17-x86_64-gold' else 1 + + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + side_effect=flavor_side_effect) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + side_effect=image_side_effect) + def _limits_absolute(self): max_personality = self.m.CreateMockAnything() max_personality.name = 'maxPersonality' @@ -224,6 +233,9 @@ class ServersTest(common.HeatTestCase): def _setup_test_server(self, return_server, name, image_id=None, override_name=False, stub_create=True): stack_name = '%s_s' % name + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id', + return_value='aaaaaa') server_name = str(name) if override_name else None tmpl, self.stack = self._get_test_template(stack_name, server_name, image_id) @@ -232,50 +244,23 @@ class ServersTest(common.HeatTestCase): self.stack) self.patchobject(server, 'store_external_ports') - - self._mock_get_image_id_success(image_id or 'CentOS 5.2', 1) - self.stub_FlavorConstraint_validate() - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) if stub_create: - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=1, flavor=1, key_name='test', - name=override_name and server.name or utils.PhysName( - stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn(return_server) + self.patchobject(self.fc.servers, 'create', + return_value=return_server) # mock check_create_complete innards - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).AndReturn(return_server) - + self.patchobject(self.fc.servers, 'get', + return_value=return_server) return server def _create_test_server(self, return_server, name, override_name=False, stub_create=True): server = self._setup_test_server(return_server, name, stub_create=stub_create) - self.m.ReplayAll() scheduler.TaskRunner(server.create)() - self.m.UnsetStubs() return server - def _stub_glance_for_update(self, image_id=None, rebuild=False): - if rebuild: - image = 'F17-x86_64-gold' - imageId = 744 - else: - image = image_id or 'CentOS 5.2' - imageId = 1 - - self._mock_get_image_id_success(image, imageId) - def _create_fake_iface(self, port, mac, ip): class fake_interface(object): def __init__(self, port_id, mac_addr, fixed_ip): @@ -285,42 +270,7 @@ class ServersTest(common.HeatTestCase): return fake_interface(port, mac, ip) - def _mock_get_image_id_success(self, imageId_input, imageId): - self.m.StubOutWithMock(glance.GlanceClientPlugin, - 'find_image_by_name_or_id') - glance.GlanceClientPlugin.find_image_by_name_or_id( - imageId_input).MultipleTimes().AndReturn(imageId) - - def _mock_get_image_id_fail(self, image_id, exp): - self.m.StubOutWithMock(glance.GlanceClientPlugin, - 'find_image_by_name_or_id') - glance.GlanceClientPlugin.find_image_by_name_or_id( - image_id).AndRaise(exp) - - def _mock_get_keypair_success(self, keypair_input, keypair): - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_keypair') - nova.NovaClientPlugin.get_keypair( - keypair_input).MultipleTimes().AndReturn(keypair) - - def _server_validate_mock(self, server): - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.stub_VolumeConstraint_validate() - - def _mock_validate_flavor_image_success(self, image='F17-x86_64-gold', - flavor='m1.large'): - self.m.StubOutWithMock(glance.GlanceClientPlugin, 'get_image') - glance.GlanceClientPlugin.get_image( - image).AndReturn(self.mock_image) - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_flavor') - nova.NovaClientPlugin.get_flavor(flavor).MultipleTimes().AndReturn( - self.mock_flavor) - def test_subnet_dependency(self): - self.resolve = self.patchobject(neutronV20, - 'find_resourceid_by_name_or_id') - self.resolve.return_value = '12345' template, stack = self._setup_test_stack('subnet-test', subnet_template) server_rsrc = stack['server'] @@ -332,9 +282,6 @@ class ServersTest(common.HeatTestCase): self.assertEqual(subnet_rsrc, deps[3]) def test_subnet_nodeps(self): - self.resolve = self.patchobject(neutronV20, - 'find_resourceid_by_name_or_id') - self.resolve.return_value = '12345' template, stack = self._setup_test_stack('subnet-test', no_subnet_template) server_rsrc = stack['server'] @@ -361,13 +308,9 @@ class ServersTest(common.HeatTestCase): self._create_fake_iface( '1013', 'fa:16:3e:8c:44:cc', '10.13.12.13')] - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('5678').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().MultipleTimes().AndReturn(interfaces) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', return_value=return_server) + self.patchobject(return_server, 'interface_list', + return_value=interfaces) public_ip = return_server.networks['public'][0] self.assertEqual('1234', server.FnGetAtt('addresses')['public'][0]['port']) @@ -394,11 +337,11 @@ class ServersTest(common.HeatTestCase): expected_name = utils.PhysName(stack_name, server.name) self.assertEqual(expected_name, server.FnGetAtt('name')) - self.m.VerifyAll() - def test_server_create_metadata(self): - return_server = self.fc.servers.list()[1] stack_name = 'create_metadata_test_stack' + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + return_server = self.fc.servers.list()[1] (tmpl, stack) = self._setup_test_stack(stack_name) tmpl['Resources']['WebServer']['Properties'][ @@ -408,25 +351,11 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - instance_meta = {'a': "1"} - image_id = mox.IgnoreArg() - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=image_id, flavor=mox.IgnoreArg(), key_name='test', - name=mox.IgnoreArg(), security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=instance_meta, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn(return_server) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', image_id) - self.m.ReplayAll() - + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.m.VerifyAll() + args, kwargs = mock_create.call_args + self.assertEqual(kwargs['meta'], {'a': "1"}) def test_server_create_with_image_id(self): return_server = self.fc.servers.list()[1] @@ -434,7 +363,6 @@ class ServersTest(common.HeatTestCase): server_name = 'test_server_create_image_id' server = self._setup_test_server(return_server, server_name, - image_id='1', override_name=True) interfaces = [ @@ -443,15 +371,11 @@ class ServersTest(common.HeatTestCase): self._create_fake_iface( '1013', 'fa:16:3e:8c:44:cc', '10.13.12.13')] - self.fc.servers.get('5678').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().MultipleTimes().AndReturn(interfaces) - self.m.ReplayAll() - scheduler.TaskRunner(server.create)() - - # this makes sure the auto increment worked on server creation - self.assertTrue(server.id > 0) + self.patchobject(self.fc.servers, 'get', return_value=return_server) + self.patchobject(return_server, 'interface_list', + return_value=interfaces) + self.patchobject(return_server, 'interface_detach') + self.patchobject(return_server, 'interface_attach') public_ip = return_server.networks['public'][0] self.assertEqual('1234', @@ -473,85 +397,40 @@ class ServersTest(common.HeatTestCase): self.assertEqual(server_name, server.FnGetAtt('name')) - self.m.VerifyAll() - - def test_server_create_image_name_err(self): + def test_server_image_name_err(self): stack_name = 'img_name_err' (tmpl, stack) = self._setup_test_stack(stack_name) - - # create a server with non exist image name + mock_image = self.patchobject(glance.GlanceClientPlugin, + 'find_image_by_name_or_id') + mock_image.side_effect = [glance.exceptions.NotFound( + 'Image Slackware Not Found')] + # Init a server with non exist image name tmpl['Resources']['WebServer']['Properties']['image'] = 'Slackware' resource_defns = tmpl.resource_definitions(stack) server = servers.Server('WebServer', resource_defns['WebServer'], stack) - self._mock_get_image_id_fail('Slackware', - glance.exceptions.NotFound()) - self.stub_FlavorConstraint_validate() - self.stub_KeypairConstraint_validate() - self.m.ReplayAll() + error = self.assertRaises(glance.exceptions.NotFound, + scheduler.TaskRunner(server.create)) + self.assertEqual("Image Slackware Not Found (HTTP 404)", + six.text_type(error)) - create = scheduler.TaskRunner(server.create) - error = self.assertRaises(exception.ResourceFailure, create) - self.assertEqual( - "StackValidationFailed: resources.WebServer: Property error: " - "WebServer.Properties.image: Error validating value 'Slackware': " - "Not Found (HTTP 404)", - six.text_type(error)) - - self.m.VerifyAll() - - def test_server_create_duplicate_image_name_err(self): + def test_server_duplicate_image_name_err(self): stack_name = 'img_dup_err' (tmpl, stack) = self._setup_test_stack(stack_name) - - # create a server with a non unique image name + mock_image = self.patchobject(glance.GlanceClientPlugin, + 'find_image_by_name_or_id') + mock_image.side_effect = [glance.exceptions.NoUniqueMatch( + 'Image CentOS 5.2 is not Unique')] tmpl['Resources']['WebServer']['Properties']['image'] = 'CentOS 5.2' resource_defns = tmpl.resource_definitions(stack) server = servers.Server('WebServer', resource_defns['WebServer'], stack) - self._mock_get_image_id_fail('CentOS 5.2', - glance.exceptions.NoUniqueMatch()) - self.stub_FlavorConstraint_validate() - self.stub_KeypairConstraint_validate() - self.m.ReplayAll() - - create = scheduler.TaskRunner(server.create) - error = self.assertRaises(exception.ResourceFailure, create) - self.assertEqual( - "StackValidationFailed: resources.WebServer: Property error: " - "WebServer.Properties.image: " - "Error validating value 'CentOS 5.2': ", - six.text_type(error)) - - self.m.VerifyAll() - - def test_server_create_image_id_err(self): - stack_name = 'img_id_err' - (tmpl, stack) = self._setup_test_stack(stack_name) - - # create a server with non exist image Id - tmpl['Resources']['WebServer']['Properties']['image'] = '1' - resource_defns = tmpl.resource_definitions(stack) - server = servers.Server('WebServer', - resource_defns['WebServer'], stack) - - self._mock_get_image_id_fail('1', - glance.exceptions.NotFound()) - self.stub_KeypairConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - - create = scheduler.TaskRunner(server.create) - error = self.assertRaises(exception.ResourceFailure, create) - self.assertEqual( - "StackValidationFailed: resources.WebServer: Property error: " - "WebServer.Properties.image: Error validating value '1': " - "Not Found (HTTP 404)", - six.text_type(error)) - - self.m.VerifyAll() + error = self.assertRaises(glance.exceptions.NoUniqueMatch, + scheduler.TaskRunner(server.create)) + self.assertEqual('Image CentOS 5.2 is not Unique', + six.text_type(error)) def test_server_create_unexpected_status(self): # NOTE(pshchelo) checking is done only on check_create_complete @@ -560,11 +439,9 @@ class ServersTest(common.HeatTestCase): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'cr_unexp_sts') - self.m.StubOutWithMock(self.fc.servers, 'get') return_server.status = 'BOGUS' - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + return_value=return_server) e = self.assertRaises(exception.ResourceUnknownStatus, server.check_create_complete, server.resource_id) @@ -584,10 +461,8 @@ class ServersTest(common.HeatTestCase): 'code': 500, 'created': '2013-08-14T03:12:10Z' } - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + return_value=return_server) e = self.assertRaises(exception.ResourceInError, server.check_create_complete, server.resource_id) @@ -595,13 +470,12 @@ class ServersTest(common.HeatTestCase): 'Went to status ERROR due to "Message: NoValidHost, Code: 500"', six.text_type(e)) - self.m.VerifyAll() - def test_server_create_raw_userdata(self): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (tmpl, stack) = self._setup_test_stack(stack_name) - tmpl['Resources']['WebServer']['Properties'][ 'user_data_format'] = 'RAW' @@ -610,31 +484,18 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata='wordpress', scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.m.VerifyAll() + args, kwargs = mock_create.call_args + self.assertEqual(kwargs['userdata'], 'wordpress') def test_server_create_raw_config_userdata(self): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (tmpl, stack) = self._setup_test_stack(stack_name) - tmpl['Resources']['WebServer']['Properties'][ 'user_data_format'] = 'RAW' tmpl['Resources']['WebServer']['Properties'][ @@ -650,37 +511,22 @@ class ServersTest(common.HeatTestCase): sc = {'config': 'wordpress from config'} self.rpc_client.show_software_config.return_value = sc - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata='wordpress from config', scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.m.VerifyAll() + args, kwargs = mock_create.call_args + self.assertEqual(kwargs['userdata'], 'wordpress from config') def test_server_create_raw_config_userdata_None(self): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'raw_userdata_s' (tmpl, stack) = self._setup_test_stack(stack_name) - sc_id = '8c813873-f6ee-4809-8eec-959ef39acb55' tmpl['Resources']['WebServer']['Properties'][ 'user_data_format'] = 'RAW' tmpl['Resources']['WebServer']['Properties']['user_data'] = sc_id - resource_defns = tmpl.resource_definitions(stack) server = servers.Server('WebServer', resource_defns['WebServer'], stack) @@ -690,34 +536,20 @@ class ServersTest(common.HeatTestCase): server._rpc_client = self.rpc_client self.rpc_client.show_software_config.side_effect = exception.NotFound - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=sc_id, - scheduler_hints=None, meta=None, - nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn(return_server) - - self.m.ReplayAll() + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.m.VerifyAll() + args, kwargs = mock_create.call_args + self.assertEqual(kwargs['userdata'], sc_id) def _server_create_software_config(self, md=None, stack_name='software_config_s', ret_tmpl=False): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] (tmpl, stack) = self._setup_test_stack(stack_name) self.stack = stack - tmpl['Resources']['WebServer']['Properties'][ 'user_data_format'] = 'SOFTWARE_CONFIG' if md is not None: @@ -728,25 +560,9 @@ class ServersTest(common.HeatTestCase): server = servers.Server('WebServer', resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - self.m.StubOutWithMock(server, 'heat') - - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + self.patchobject(server, 'heat') + self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() self.assertEqual('4567', server.access_key) @@ -758,7 +574,6 @@ class ServersTest(common.HeatTestCase): self.assertTrue(stack.access_allowed('4567', 'WebServer')) self.assertFalse(stack.access_allowed('45678', 'WebServer')) self.assertFalse(stack.access_allowed('4567', 'wWebServer')) - self.m.VerifyAll() if ret_tmpl: return server, tmpl else: @@ -805,6 +620,8 @@ class ServersTest(common.HeatTestCase): }, server.metadata_get()) def _server_create_software_config_poll_heat(self, md=None): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'software_config_s' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -820,32 +637,14 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.assertEqual('1234', server._get_user_id()) self.assertTrue(stack.access_allowed('1234', 'WebServer')) self.assertFalse(stack.access_allowed('45678', 'WebServer')) self.assertFalse(stack.access_allowed('4567', 'wWebServer')) - self.m.VerifyAll() return stack, server def test_server_create_software_config_poll_heat(self): @@ -887,6 +686,8 @@ class ServersTest(common.HeatTestCase): }, server.metadata_get()) def _server_create_software_config_poll_temp_url(self, md=None): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'software_config_s' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -902,34 +703,17 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - self.m.StubOutWithMock(swift.SwiftClientPlugin, '_create') - sc = mock.Mock() sc.head_account.return_value = { 'x-account-meta-temp-url-key': 'secrit' } sc.url = 'http://192.0.2.2' - swift.SwiftClientPlugin._create().AndReturn(sc) - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + self.patchobject(swift.SwiftClientPlugin, '_create', + return_value=sc) + self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - metadata_put_url = server.data().get('metadata_put_url') md = server.metadata_get() metadata_url = md['os-collect-config']['request']['metadata_url'] @@ -950,8 +734,6 @@ class ServersTest(common.HeatTestCase): sc.delete_object.assert_called_once_with(container_name, object_name) sc.head_container.assert_called_once_with(container_name) sc.delete_container.assert_called_once_with(container_name) - - self.m.VerifyAll() return metadata_url, server def test_server_create_software_config_poll_temp_url(self): @@ -985,10 +767,11 @@ class ServersTest(common.HeatTestCase): }, server.metadata_get()) def _server_create_software_config_zaqar(self, md=None): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] stack_name = 'software_config_s' (tmpl, stack) = self._setup_test_stack(stack_name) - props = tmpl.t['Resources']['WebServer']['Properties'] props['user_data_format'] = 'SOFTWARE_CONFIG' props['software_config_transport'] = 'ZAQAR_MESSAGE' @@ -1000,29 +783,13 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - ncp = self.patchobject(nova.NovaClientPlugin, '_create') zcc = self.patchobject(zaqar.ZaqarClientPlugin, 'create_for_tenant') zc = mock.Mock() - - ncp.return_value = self.fc zcc.return_value = zc queue = mock.Mock() zc.queue.return_value = queue - self._mock_get_image_id_success('F17-x86_64-gold', 744) - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn( - return_server) - - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() metadata_queue_id = server.data().get('metadata_queue_id') @@ -1040,8 +807,6 @@ class ServersTest(common.HeatTestCase): zc.queue.assert_called_once_with(queue_id) zc.queue(queue_id).delete.assert_called_once_with() - - self.m.VerifyAll() return queue_id, server def test_server_create_software_config_zaqar(self): @@ -1078,8 +843,7 @@ class ServersTest(common.HeatTestCase): 'deployments': [] }, server.metadata_get()) - @mock.patch.object(nova.NovaClientPlugin, '_create') - def test_server_create_default_admin_pass(self, mock_client): + def test_server_create_default_admin_pass(self): return_server = self.fc.servers.list()[1] return_server.adminPass = 'autogenerated' stack_name = 'admin_pass_s' @@ -1090,23 +854,15 @@ class ServersTest(common.HeatTestCase): resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - mock_client.return_value = self.fc - self.fc.servers.create = mock.Mock(return_value=return_server) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mock.ANY, scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None) + _, kwargs = mock_create.call_args + self.assertEqual(kwargs['admin_pass'], None) - @mock.patch.object(nova.NovaClientPlugin, '_create') - def test_server_create_custom_admin_pass(self, mock_client): + def test_server_create_custom_admin_pass(self): return_server = self.fc.servers.list()[1] return_server.adminPass = 'foo' stack_name = 'admin_pass_s' @@ -1117,23 +873,17 @@ class ServersTest(common.HeatTestCase): server = servers.Server('WebServer', resource_defns['WebServer'], stack) self.patchobject(server, 'store_external_ports') - - mock_client.return_value = self.fc - self.fc.servers.create = mock.Mock(return_value=return_server) - self._mock_get_image_id_success('F17-x86_64-gold', 744) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) scheduler.TaskRunner(server.create)() - self.fc.servers.create( - image=744, flavor=3, key_name='test', - name=utils.PhysName(stack_name, server.name), - security_groups=[], - userdata=mock.ANY, scheduler_hints=None, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass='foo') + _, kwargs = mock_create.call_args + self.assertEqual(kwargs['admin_pass'], 'foo') def test_server_create_with_stack_scheduler_hints(self): + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) return_server = self.fc.servers.list()[1] return_server.id = '5678' sh.cfg.CONF.set_override('stack_scheduler_hints', True) @@ -1152,36 +902,22 @@ class ServersTest(common.HeatTestCase): stack.add_resource(server) self.assertIsNotNone(server.uuid) - self._mock_get_image_id_success('CentOS 5.2', 1) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().MultipleTimes().AndReturn(self.fc) - - self.m.StubOutWithMock(self.fc.servers, 'create') + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) shm = sh.SchedulerHintsMixin - self.fc.servers.create( - image=1, flavor=1, key_name='test', - name=server_name, - security_groups=[], - userdata=mox.IgnoreArg(), - scheduler_hints={shm.HEAT_ROOT_STACK_ID: stack.root_stack_id(), - shm.HEAT_STACK_ID: stack.id, - shm.HEAT_STACK_NAME: stack.name, - shm.HEAT_PATH_IN_STACK: [(None, stack.name)], - shm.HEAT_RESOURCE_NAME: server.name, - shm.HEAT_RESOURCE_UUID: server.uuid}, - meta=None, nics=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn(return_server) + scheduler_hints = {shm.HEAT_ROOT_STACK_ID: stack.root_stack_id(), + shm.HEAT_STACK_ID: stack.id, + shm.HEAT_STACK_NAME: stack.name, + shm.HEAT_PATH_IN_STACK: [(None, stack.name)], + shm.HEAT_RESOURCE_NAME: server.name, + shm.HEAT_RESOURCE_UUID: server.uuid} - self.m.ReplayAll() scheduler.TaskRunner(server.create)() + _, kwargs = mock_create.call_args + self.assertEqual(kwargs['scheduler_hints'], scheduler_hints) # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) - self.m.VerifyAll() - def test_check_maximum(self): msg = 'test_check_maximum' self.assertIsNone(servers.Server._check_maximum(1, 1, msg)) @@ -1194,38 +930,27 @@ class ServersTest(common.HeatTestCase): def test_server_validate(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) - - tmpl.t['Resources']['WebServer']['Properties']['image'] = '1' + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('1', 1) - - self._mock_validate_flavor_image_success(image='1') - - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_server_validate_with_bootable_vol(self): stack_name = 'srv_val_bootvol' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + self.stub_VolumeConstraint_validate() # create a server with bootable volume web_server = tmpl.t['Resources']['WebServer'] del web_server['Properties']['image'] - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - - self.stub_VolumeConstraint_validate() - self.m.ReplayAll() - def create_server(device_name): web_server['Properties']['block_device_mapping'] = [{ "device_name": device_name, @@ -1247,7 +972,6 @@ class ServersTest(common.HeatTestCase): self.assertEqual('Neither image nor bootable volume is specified for ' 'instance server_with_bootable_volume', six.text_type(ex)) - self.m.VerifyAll() def test_server_validate_with_nova_keypair_resource(self): stack_name = 'srv_val_test' @@ -1278,53 +1002,47 @@ class ServersTest(common.HeatTestCase): return_value=True) t = template_format.parse(nova_keypair_template) templ = template.Template(t) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) stack = parser.Stack(utils.dummy_context(), stack_name, templ, stack_id=uuidutils.generate_uuid()) - resource_defns = templ.resource_definitions(stack) server = servers.Server('server_validate_test', resource_defns['WebServer'], stack) - self.stub_ImageConstraint_validate() - self.stub_FlavorConstraint_validate() - self._mock_validate_flavor_image_success() - - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_server_validate_with_invalid_ssh_key(self): stack_name = 'srv_val_test' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) web_server = tmpl['Resources']['WebServer'] - # Make the ssh key have an invalid name web_server['Properties']['key_name'] = 'test2' resource_defns = tmpl.resource_definitions(stack) server = servers.Server('WebServer', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_ImageConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( "Property error: Resources.WebServer.Properties.key_name: " "Error validating value 'test2': The Key (test2) could not " "be found.", six.text_type(error)) - self.m.VerifyAll() def test_server_validate_software_config_invalid_meta(self): stack_name = 'srv_val_test' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) web_server = tmpl['Resources']['WebServer'] web_server['Properties']['user_data_format'] = 'SOFTWARE_CONFIG' web_server['Metadata'] = {'deployments': 'notallowed'} @@ -1332,19 +1050,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('WebServer', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_ImageConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( "deployments key not allowed in resource metadata " "with user_data_format of SOFTWARE_CONFIG", six.text_type(error)) - self.m.VerifyAll() def test_server_validate_with_networks(self): stack_name = 'srv_net' @@ -1367,22 +1081,21 @@ class ServersTest(common.HeatTestCase): def test_server_validate_with_network_empty_ref(self): stack_name = 'srv_net' (tmpl, stack) = self._setup_test_stack(stack_name) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'network': ''}]) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_with_networks', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.stub_NetworkConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_with_only_fixed_ip(self): stack_name = 'srv_net' @@ -1390,25 +1103,23 @@ class ServersTest(common.HeatTestCase): # create a server with 'uuid' and 'network' properties tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'fixed_ip': '10.0.0.99'}]) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_with_networks', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.stub_NetworkConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn(_('One of the properties "network", "port" or "subnet" ' 'should be set for the specified network of ' 'server "%s".') % server.name, six.text_type(ex)) - self.m.VerifyAll() def test_server_validate_with_port_fixed_ip(self): stack_name = 'srv_net' @@ -1416,50 +1127,50 @@ class ServersTest(common.HeatTestCase): tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '10.0.0.99'}]) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_with_networks', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_ImageConstraint_validate() - self._mock_validate_flavor_image_success() - self.stub_NetworkConstraint_validate() - self.stub_PortConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') error = self.assertRaises(exception.ResourcePropertyConflict, server.validate) self.assertEqual("Cannot define the following properties at the same " "time: networks/fixed_ip, networks/port.", six.text_type(error)) - self.m.VerifyAll() def test_server_validate_with_port_not_using_neutron(self): stack_name = 'with_port_in_nova_network' (tmpl, stack) = self._setup_test_stack(stack_name) tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}]) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) + self.patchobject(servers.Server, + 'is_using_neutron', return_value=False) + + # We're patching neutron finder here as constraint validation + # does not check if neutron is enabled or not. This would be + # fixed in a subsequent patch. + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') resource_defns = tmpl.resource_definitions(stack) server = servers.Server('validate_port_in_nova_network', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_validate_flavor_image_success() - self.stub_ImageConstraint_validate() - self.stub_NetworkConstraint_validate() - self.stub_PortConstraint_validate() - self.patchobject(server, 'is_using_neutron', return_value=False) - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual('Property "port" is supported only for Neutron.', six.text_type(error)) - self.m.VerifyAll() def test_server_validate_with_uuid_fixed_ip(self): stack_name = 'srv_net' @@ -1467,21 +1178,18 @@ class ServersTest(common.HeatTestCase): tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'uuid': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', 'fixed_ip': '10.0.0.99'}]) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_with_networks', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.stub_NetworkConstraint_validate() - - self.m.ReplayAll() - + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_with_network_fixed_ip(self): stack_name = 'srv_net' @@ -1489,21 +1197,18 @@ class ServersTest(common.HeatTestCase): tmpl['Resources']['WebServer']['Properties']['networks'] = ( [{'network': 'public', 'fixed_ip': '10.0.0.99'}]) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_with_networks', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.stub_NetworkConstraint_validate() - - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_net_security_groups(self): # Test that if network 'ports' are assigned security groups are @@ -1515,25 +1220,22 @@ class ServersTest(common.HeatTestCase): {'port': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}] tmpl['Resources']['WebServer']['Properties'][ 'security_groups'] = ['my_security_group'] - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_validate_net_security_groups', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.stub_PortConstraint_validate() - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id') error = self.assertRaises(exception.ResourcePropertyConflict, server.validate) self.assertEqual("Cannot define the following properties at the same " "time: security_groups, networks/port.", six.text_type(error)) - self.m.VerifyAll() def test_server_delete(self): return_server = self.fc.servers.list()[1] @@ -1544,15 +1246,10 @@ class ServersTest(common.HeatTestCase): # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(server) - self.fc.servers.get(server.resource_id).AndRaise( - fakes_nova.fake_exception()) - self.m.ReplayAll() - + side_effect = [server, fakes_nova.fake_exception()] + self.patchobject(self.fc.servers, 'get', side_effect=side_effect) scheduler.TaskRunner(server.delete)() self.assertEqual((server.DELETE, server.COMPLETE), server.state) - self.m.VerifyAll() def test_server_delete_notfound(self): return_server = self.fc.servers.list()[1] @@ -1563,14 +1260,10 @@ class ServersTest(common.HeatTestCase): # this makes sure the auto increment worked on server creation self.assertTrue(server.id > 0) - self.m.StubOutWithMock(self.fc.client, 'delete_servers_1234') - self.fc.client.delete_servers_1234().AndRaise( - fakes_nova.fake_exception()) - self.m.ReplayAll() - + self.patchobject(self.fc.client, 'delete_servers_1234', + side_effect=fakes_nova.fake_exception()) scheduler.TaskRunner(server.delete)() self.assertEqual((server.DELETE, server.COMPLETE), server.state) - self.m.VerifyAll() def test_server_delete_error(self): return_server = self.fc.servers.list()[1] @@ -1583,21 +1276,16 @@ class ServersTest(common.HeatTestCase): def make_error(*args): return_server.status = "ERROR" + return return_server - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.fc.servers.get(server.resource_id).WithSideEffects( - make_error).AndReturn(return_server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + side_effect=[return_server, return_server, + make_error()]) resf = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.delete)) self.assertIn("Server %s delete failed" % return_server.name, six.text_type(resf)) - self.m.VerifyAll() - def test_server_delete_error_task_in_progress(self): # test server in 'ERROR', but task state in nova is 'deleting' return_server = self.fc.servers.list()[1] @@ -1608,23 +1296,20 @@ class ServersTest(common.HeatTestCase): def make_error(*args): return_server.status = "ERROR" setattr(return_server, 'OS-EXT-STS:task_state', 'deleting') + return return_server def make_error_done(*args): return_server.status = "ERROR" setattr(return_server, 'OS-EXT-STS:task_state', None) + return return_server - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).WithSideEffects( - make_error).AndReturn(return_server) - self.fc.servers.get(server.resource_id).WithSideEffects( - make_error_done).AndReturn(return_server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + side_effect=[make_error(), + make_error_done()]) resf = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.delete)) self.assertIn("Server %s delete failed" % return_server.name, six.text_type(resf)) - self.m.VerifyAll() def test_server_soft_delete(self): return_server = self.fc.servers.list()[1] @@ -1637,29 +1322,21 @@ class ServersTest(common.HeatTestCase): def make_soft_delete(*args): return_server.status = "SOFT_DELETED" - - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.fc.servers.get(server.resource_id).WithSideEffects( - make_soft_delete).AndReturn(return_server) - self.m.ReplayAll() - + return return_server + self.patchobject(self.fc.servers, 'get', + side_effect=[return_server, return_server, + make_soft_delete()]) scheduler.TaskRunner(server.delete)() self.assertEqual((server.DELETE, server.COMPLETE), server.state) - self.m.VerifyAll() def test_server_update_metadata(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') - - self._stub_glance_for_update() ud_tmpl = self._get_test_template('update_stack')[0] ud_tmpl.t['Resources']['WebServer']['Metadata'] = {'test': 123} resource_defns = ud_tmpl.resource_definitions(server.stack) - self.m.ReplayAll() scheduler.TaskRunner(server.update, resource_defns['WebServer'])() self.assertEqual({'test': 123}, server.metadata_get()) @@ -1669,7 +1346,6 @@ class ServersTest(common.HeatTestCase): self.assertEqual({'test': 123}, server.metadata_get()) server.metadata_update() self.assertEqual({'test': 456}, server.metadata_get()) - self.m.VerifyAll() @mock.patch.object(heat_plugin.HeatClientPlugin, 'url_for') def test_server_update_metadata_software_config(self, fake_url): @@ -1690,20 +1366,13 @@ class ServersTest(common.HeatTestCase): }, 'deployments': []} self.assertEqual(expected_md, server.metadata_get()) - - self.m.UnsetStubs() - self._stub_glance_for_update(rebuild=True) - ud_tmpl.t['Resources']['WebServer']['Metadata'] = {'test': 123} resource_defns = ud_tmpl.resource_definitions(server.stack) - - self.m.ReplayAll() scheduler.TaskRunner(server.update, resource_defns['WebServer'])() expected_md.update({'test': 123}) self.assertEqual(expected_md, server.metadata_get()) server.metadata_update() self.assertEqual(expected_md, server.metadata_get()) - self.m.VerifyAll() @mock.patch.object(heat_plugin.HeatClientPlugin, 'url_for') def test_server_update_metadata_software_config_merge(self, fake_url): @@ -1727,20 +1396,13 @@ class ServersTest(common.HeatTestCase): }, 'deployments': []} self.assertEqual(expected_md, server.metadata_get()) - - self.m.UnsetStubs() - self._stub_glance_for_update(rebuild=True) - ud_tmpl.t['Resources']['WebServer']['Metadata'] = {'test': 123} resource_defns = ud_tmpl.resource_definitions(server.stack) - - self.m.ReplayAll() scheduler.TaskRunner(server.update, resource_defns['WebServer'])() expected_md.update({'test': 123}) self.assertEqual(expected_md, server.metadata_get()) server.metadata_update() self.assertEqual(expected_md, server.metadata_get()) - self.m.VerifyAll() @mock.patch.object(heat_plugin.HeatClientPlugin, 'url_for') def test_server_update_software_config_transport(self, fake_url): @@ -1763,19 +1425,13 @@ class ServersTest(common.HeatTestCase): }, 'deployments': []} self.assertEqual(expected_md, server.metadata_get()) - - self.m.UnsetStubs() - self._stub_glance_for_update(rebuild=True) - self.m.StubOutWithMock(swift.SwiftClientPlugin, '_create') - sc = mock.Mock() sc.head_account.return_value = { 'x-account-meta-temp-url-key': 'secrit' } sc.url = 'http://192.0.2.2' - - swift.SwiftClientPlugin._create().AndReturn(sc) - + self.patchobject(swift.SwiftClientPlugin, '_create', + return_value=sc) update_template = copy.deepcopy(server.t) update_template['Properties'][ 'software_config_transport'] = 'POLL_TEMP_URL' @@ -1783,8 +1439,6 @@ class ServersTest(common.HeatTestCase): self.rpc_client = mock.MagicMock() server._rpc_client = self.rpc_client self.rpc_client.create_software_config.return_value = None - - self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) @@ -1811,7 +1465,6 @@ class ServersTest(common.HeatTestCase): 'deployments': []} md['os-collect-config']['request']['metadata_url'] = 'the_url' self.assertDictEqual(expected_md, server.metadata_get()) - self.m.VerifyAll() def test_server_update_nova_metadata(self): return_server = self.fc.servers.list()[1] @@ -1819,19 +1472,15 @@ class ServersTest(common.HeatTestCase): 'md_update') new_meta = {'test': 123} - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.m.StubOutWithMock(self.fc.servers, 'set_meta') - self.fc.servers.set_meta(return_server, - server.client_plugin().meta_serialize( - new_meta)).AndReturn(None) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + return_value=return_server) + set_meta_mock = self.patchobject(self.fc.servers, 'set_meta') update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + set_meta_mock.assert_called_with( + return_server, server.client_plugin().meta_serialize(new_meta)) def test_server_update_nova_metadata_complex(self): """Test that complex metadata values are correctly serialized to JSON. @@ -1839,28 +1488,22 @@ class ServersTest(common.HeatTestCase): Test that complex metadata values are correctly serialized to JSON when sent to Nova. """ - return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'md_update') - - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) + self.patchobject(self.fc.servers, 'get', + return_value=return_server) new_meta = {'test': {'testkey': 'testvalue'}} - self.m.StubOutWithMock(self.fc.servers, 'set_meta') + set_meta_mock = self.patchobject(self.fc.servers, 'set_meta') # If we're going to call set_meta() directly we # need to handle the serialization ourselves. - self.fc.servers.set_meta(return_server, - server.client_plugin().meta_serialize( - new_meta)).AndReturn(None) - self.m.ReplayAll() update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + set_meta_mock.assert_called_with( + return_server, server.client_plugin().meta_serialize(new_meta)) def test_server_update_nova_metadata_with_delete(self): return_server = self.fc.servers.list()[1] @@ -1868,45 +1511,35 @@ class ServersTest(common.HeatTestCase): 'md_update') # part one, add some metadata - self._stub_glance_for_update() new_meta = {'test': '123', 'this': 'that'} - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(return_server) - self.m.StubOutWithMock(self.fc.servers, 'set_meta') - self.fc.servers.set_meta(return_server, - new_meta).AndReturn(None) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + return_value=return_server) + set_meta_mock = self.patchobject(self.fc.servers, 'set_meta') update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() - self.m.UnsetStubs() + set_meta_mock.assert_called_with( + return_server, server.client_plugin().meta_serialize(new_meta)) # part two change the metadata (test removing the old key) - self.m.ReplayAll() new_meta = {'new_key': 'yeah'} # new fake with the correct metadata server.resource_id = '56789' new_return_server = self.fc.servers.list()[5] - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(new_return_server) - self.m.StubOutWithMock(self.fc.servers, 'delete_meta') - self.fc.servers.delete_meta(new_return_server, - ['test', 'this']).AndReturn(None) - - self.m.StubOutWithMock(self.fc.servers, 'set_meta') - self.fc.servers.set_meta(new_return_server, - new_meta).AndReturn(None) - self._mock_get_image_id_success('CentOS 5.2', 1) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + return_value=new_return_server) + del_meta_mock = self.patchobject(self.fc.servers, 'delete_meta') update_template = copy.deepcopy(server.t) update_template['Properties']['metadata'] = new_meta scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + del_meta_mock.assert_called_with(new_return_server, + ['test', 'this']) + set_meta_mock.assert_called_with( + new_return_server, server.client_plugin().meta_serialize(new_meta)) def test_server_update_server_name(self): """Server.handle_update supports changing the name.""" @@ -1918,16 +1551,12 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['name'] = new_name - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('5678').AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'update') + self.patchobject(self.fc.servers, 'get', + return_value=return_server) + self.patchobject(return_server, 'update') return_server.update(new_name).AndReturn(None) - self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() def test_server_update_server_admin_password(self): """Server.handle_update supports changing the admin password.""" @@ -1935,7 +1564,6 @@ class ServersTest(common.HeatTestCase): return_server.id = '5678' server = self._create_test_server(return_server, 'change_password') - self._stub_glance_for_update() new_password = 'new_password' update_template = copy.deepcopy(server.t) update_template['Properties']['admin_pass'] = new_password @@ -1958,43 +1586,26 @@ class ServersTest(common.HeatTestCase): return_server.id = '1234' server = self._create_test_server(return_server, 'srv_update') - update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.small' - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - - def status_resize(*args): - return_server.status = 'RESIZE' - - def status_verify_resize(*args): - return_server.status = 'VERIFY_RESIZE' - - def status_active(*args): - return_server.status = 'ACTIVE' - - self.fc.servers.get('1234').WithSideEffects( - status_active).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_resize).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_verify_resize).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_verify_resize).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_active).AndReturn(return_server) - - self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') - self.fc.client.post_servers_1234_action( - body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) - self.fc.client.post_servers_1234_action( - body={'confirmResize': None}).AndReturn((202, None)) - self.m.ReplayAll() + def set_status(status): + return_server.status = status + return return_server + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('ACTIVE'), + set_status('RESIZE'), + set_status('VERIFY_RESIZE'), + set_status('VERIFY_RESIZE'), + set_status('ACTIVE')]) + mock_post = self.patchobject(self.fc.client, + 'post_servers_1234_action', + return_value=(202, None)) scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + mock_post.called_once_with(body={'resize': {'flavorRef': 2}}) + mock_post.called_once_with(body={'confirmResize': None}) def test_server_update_server_flavor_failed(self): """Check raising exception due to resize call failing. @@ -2006,37 +1617,26 @@ class ServersTest(common.HeatTestCase): return_server.id = '1234' server = self._create_test_server(return_server, 'srv_update2') - - self._stub_glance_for_update() update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.small' - self.m.StubOutWithMock(self.fc.servers, 'get') - - def status_resize(*args): - return_server.status = 'RESIZE' - - def status_error(*args): - return_server.status = 'ERROR' - - self.fc.servers.get('1234').AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_resize).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_error).AndReturn(return_server) - - self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') - self.fc.client.post_servers_1234_action( - body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) - self.m.ReplayAll() + def set_status(status): + return_server.status = status + return return_server + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('RESIZE'), + set_status('ERROR')]) + mock_post = self.patchobject(self.fc.client, + 'post_servers_1234_action', + return_value=(202, None)) updater = scheduler.TaskRunner(server.update, update_template) error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( - "Error: resources.srv_update2: Resizing to 'm1.small' failed, " + "Error: resources.srv_update2: Resizing to '2' failed, " "status 'ERROR'", six.text_type(error)) self.assertEqual((server.UPDATE, server.FAILED), server.state) - self.m.VerifyAll() + mock_post.called_once_with(body={'resize': {'flavorRef': 2}}) def test_server_update_flavor_resize_has_not_started(self): """Test update of server flavor if server resize has not started. @@ -2055,75 +1655,49 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server_resource.t) update_template['Properties']['flavor'] = 'm1.small' - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - # define status transition when server resize # ACTIVE(initial) -> ACTIVE -> RESIZE -> VERIFY_RESIZE - def status_resize(*args): - server.status = 'RESIZE' + def set_status(status): + server.status = status + return server - def status_verify_resize(*args): - server.status = 'VERIFY_RESIZE' + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('ACTIVE'), + set_status('ACTIVE'), + set_status('RESIZE'), + set_status('VERIFY_RESIZE'), + set_status('VERIFY_RESIZE'), + set_status('ACTIVE')]) - def status_active(*args): - server.status = 'ACTIVE' - - self.fc.servers.get('1234').WithSideEffects( - status_active).AndReturn(server) - self.fc.servers.get('1234').WithSideEffects( - status_active).AndReturn(server) - self.fc.servers.get('1234').WithSideEffects( - status_resize).AndReturn(server) - self.fc.servers.get('1234').WithSideEffects( - status_verify_resize).AndReturn(server) - self.fc.servers.get('1234').WithSideEffects( - status_verify_resize).AndReturn(server) - self.fc.servers.get('1234').WithSideEffects( - status_active).AndReturn(server) - - self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') - self.fc.client.post_servers_1234_action( - body={'resize': {'flavorRef': 2}}).AndReturn((202, None)) - self.fc.client.post_servers_1234_action( - body={'confirmResize': None}).AndReturn((202, None)) - self.m.ReplayAll() + mock_post = self.patchobject(self.fc.client, + 'post_servers_1234_action', + return_value=(202, None)) # check that server resize has finished correctly scheduler.TaskRunner(server_resource.update, update_template)() self.assertEqual((server_resource.UPDATE, server_resource.COMPLETE), server_resource.state) - self.m.VerifyAll() + mock_post.called_once_with(body={'resize': {'flavorRef': 2}}) + mock_post.called_once_with(body={'confirmResize': None}) - def test_server_update_server_flavor_replace(self): + @mock.patch.object(servers.Server, 'prepare_for_replace') + def test_server_update_server_flavor_replace(self, mock_replace): stack_name = 'update_flvrep' (tmpl, stack) = self._setup_test_stack(stack_name) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.m.ReplayAll() - self.patchobject(servers.Server, 'prepare_for_replace') - tmpl['Resources']['WebServer']['Properties'][ 'flavor_update_policy'] = 'REPLACE' resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_server_update_flavor_replace', resource_defns['WebServer'], stack) - update_template = copy.deepcopy(server.t) update_template['Properties']['flavor'] = 'm1.small' updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(exception.UpdateReplace, updater) - def test_server_update_server_flavor_policy_update(self): + @mock.patch.object(servers.Server, 'prepare_for_replace') + def test_server_update_server_flavor_policy_update(self, mock_replace): stack_name = 'update_flvpol' (tmpl, stack) = self._setup_test_stack(stack_name) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.m.ReplayAll() - - self.patchobject(servers.Server, 'prepare_for_replace') resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_server_update_flavor_replace', resource_defns['WebServer'], stack) @@ -2137,13 +1711,12 @@ class ServersTest(common.HeatTestCase): updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(exception.UpdateReplace, updater) - def test_server_update_server_userdata_replace(self): + @mock.patch.object(servers.Server, 'prepare_for_replace') + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_server_update_server_userdata_replace(self, mock_create, + mock_replace): stack_name = 'update_udatrep' (tmpl, stack) = self._setup_test_stack(stack_name) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.m.ReplayAll() resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_update_userdata_replace', resource_defns['WebServer'], stack) @@ -2154,14 +1727,12 @@ class ServersTest(common.HeatTestCase): updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(exception.UpdateReplace, updater) - def test_server_update_server_userdata_ignore(self): + @mock.patch.object(servers.Server, 'prepare_for_replace') + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_server_update_server_userdata_ignore(self, mock_create, + mock_replace): stack_name = 'update_udatignore' (tmpl, stack) = self._setup_test_stack(stack_name) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.m.ReplayAll() - self.patchobject(servers.Server, 'prepare_for_replace') self.patchobject(servers.Server, 'check_update_complete', return_value=True) @@ -2175,12 +1746,11 @@ class ServersTest(common.HeatTestCase): server.action = server.CREATE scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_server_update_image_replace(self): + @mock.patch.object(servers.Server, 'prepare_for_replace') + def test_server_update_image_replace(self, mock_replace): stack_name = 'update_imgrep' (tmpl, stack) = self._setup_test_stack(stack_name) - self.patchobject(servers.Server, 'prepare_for_replace') tmpl.t['Resources']['WebServer']['Properties'][ 'image_update_policy'] = 'REPLACE' @@ -2188,12 +1758,6 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_update_image_replace', resource_defns['WebServer'], stack) image_id = self.getUniqueString() - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_ImageConstraint_validate() - - self.m.ReplayAll() - update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = image_id updater = scheduler.TaskRunner(server.update, update_template) @@ -2209,7 +1773,6 @@ class ServersTest(common.HeatTestCase): 'srv_updimgrbld') new_image = 'F17-x86_64-gold' - self._stub_glance_for_update(rebuild=True) # current test demonstrate updating when image_update_policy was not # changed, so image_update_policy will be used from self.properties server.t['Properties']['image_update_policy'] = policy @@ -2219,33 +1782,29 @@ class ServersTest(common.HeatTestCase): if password: update_template['Properties']['admin_pass'] = password - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('1234').AndReturn(return_server) - self.m.StubOutWithMock(self.fc.servers, 'rebuild') - # 744 is a static lookup from the fake images list - if 'REBUILD' == policy: - self.fc.servers.rebuild( - return_server, 744, password=password, - preserve_ephemeral=False) - else: - self.fc.servers.rebuild( - return_server, 744, password=password, - preserve_ephemeral=True) - self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') + mock_rebuild = self.patchobject(self.fc.servers, 'rebuild') def get_sideeff(stat): def sideeff(*args): return_server.status = stat + return return_server return sideeff for stat in status: - self.fc.servers.get('1234').WithSideEffects( - get_sideeff(stat)).AndReturn(return_server) + self.patchobject(self.fc.servers, 'get', + side_effect=get_sideeff(stat)) - self.m.ReplayAll() scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + + if 'REBUILD' == policy: + mock_rebuild.assert_called_once_with( + return_server, '2', password=password, + preserve_ephemeral=False) + else: + mock_rebuild.assert_called_once_with( + return_server, '2', password=password, + preserve_ephemeral=True) def test_server_update_image_rebuild_status_rebuild(self): # Normally we will see 'REBUILD' first and then 'ACTIVE". @@ -2267,6 +1826,7 @@ class ServersTest(common.HeatTestCase): def test_server_update_image_rebuild_with_new_password(self): # Normally we will see 'REBUILD' first and then 'ACTIVE". + self._test_server_update_image_rebuild(password='new_admin_password', status=('REBUILD', 'ACTIVE')) @@ -2279,33 +1839,20 @@ class ServersTest(common.HeatTestCase): 'srv_updrbldfail') new_image = 'F17-x86_64-gold' - self._stub_glance_for_update(rebuild=True) # current test demonstrate updating when image_update_policy was not # changed, so image_update_policy will be used from self.properties server.t['Properties']['image_update_policy'] = 'REBUILD' update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = new_image + mock_rebuild = self.patchobject(self.fc.servers, 'rebuild') - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('1234').AndReturn(return_server) - self.m.StubOutWithMock(self.fc.servers, 'rebuild') - # 744 is a static lookup from the fake images list - self.fc.servers.rebuild( - return_server, 744, password=None, preserve_ephemeral=False) - self.m.StubOutWithMock(self.fc.client, 'post_servers_1234_action') - - def status_rebuild(*args): - return_server.status = 'REBUILD' - - def status_error(*args): - return_server.status = 'ERROR' - - self.fc.servers.get('1234').WithSideEffects( - status_rebuild).AndReturn(return_server) - self.fc.servers.get('1234').WithSideEffects( - status_error).AndReturn(return_server) - self.m.ReplayAll() + def set_status(status): + return_server.status = status + return return_server + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('REBUILD'), + set_status('ERROR')]) updater = scheduler.TaskRunner(server.update, update_template) error = self.assertRaises(exception.ResourceFailure, updater) self.assertEqual( @@ -2313,18 +1860,15 @@ class ServersTest(common.HeatTestCase): "Rebuilding server failed, status 'ERROR'", six.text_type(error)) self.assertEqual((server.UPDATE, server.FAILED), server.state) - self.m.VerifyAll() + mock_rebuild.assert_called_once_with( + return_server, '2', password=None, preserve_ephemeral=False) def test_server_update_properties(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'update_prop') - - self.stub_ImageConstraint_validate() - self.m.ReplayAll() - update_template = copy.deepcopy(server.t) - update_template['Properties']['image'] = 'mustreplace' + update_template['Properties']['image'] = 'F17-x86_64-gold' update_template['Properties']['image_update_policy'] = 'REPLACE' updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(exception.UpdateReplace, updater) @@ -2337,11 +1881,10 @@ class ServersTest(common.HeatTestCase): def status_active(*args): return_server.status = 'ACTIVE' + return return_server - self.fc.servers.get(server.resource_id).WithSideEffects( - status_active).AndReturn(return_server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + return_value=status_active()) scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) @@ -2349,9 +1892,7 @@ class ServersTest(common.HeatTestCase): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_sus1') - server.resource_id = None - self.m.ReplayAll() ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) @@ -2361,19 +1902,13 @@ class ServersTest(common.HeatTestCase): six.text_type(ex)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) - self.m.VerifyAll() - def test_server_status_suspend_not_found(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_sus2') - server.resource_id = '1234' - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndRaise( - fakes_nova.fake_exception()) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + side_effect=fakes_nova.fake_exception()) ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) self.assertEqual('NotFound: resources.srv_sus2: ' @@ -2381,8 +1916,6 @@ class ServersTest(common.HeatTestCase): six.text_type(ex)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) - self.m.VerifyAll() - def _test_server_status_suspend(self, name, state=('CREATE', 'COMPLETE')): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, name) @@ -2390,29 +1923,19 @@ class ServersTest(common.HeatTestCase): server.resource_id = '1234' server.state_set(state[0], state[1]) - def status_suspended(*args): - return_server.status = 'SUSPENDED' + def set_status(status): + return_server.status = status + return return_server - def status_active(*args): - return_server.status = 'ACTIVE' - - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).WithSideEffects( - status_active).AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'suspend') - return_server.suspend().AndReturn(None) - self.fc.servers.get(return_server.id).WithSideEffects( - status_active).AndReturn(return_server) - self.fc.servers.get(return_server.id).WithSideEffects( - status_suspended).AndReturn(return_server) - self.m.ReplayAll() + self.patchobject(return_server, 'suspend') + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('ACTIVE'), + set_status('ACTIVE'), + set_status('SUSPENDED')]) scheduler.TaskRunner(server.suspend)() self.assertEqual((server.SUSPEND, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_server_suspend_in_create_complete(self): self._test_server_status_suspend('test_suspend_in_create_complete') @@ -2430,27 +1953,17 @@ class ServersTest(common.HeatTestCase): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_susp_uk') - server.resource_id = '1234' - def status_unknown(*args): - return_server.status = 'TRANSMOGRIFIED' - - def status_active(*args): - return_server.status = 'ACTIVE' - - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).WithSideEffects( - status_active).AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'suspend') - return_server.suspend().AndReturn(None) - self.fc.servers.get(return_server.id).WithSideEffects( - status_active).AndReturn(return_server) - self.fc.servers.get(return_server.id).WithSideEffects( - status_unknown).AndReturn(return_server) - self.m.ReplayAll() + def set_status(status): + return_server.status = status + return return_server + self.patchobject(return_server, 'suspend') + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('ACTIVE'), + set_status('ACTIVE'), + set_status('TRANSMOGRIFIED')]) ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.suspend)) self.assertIsInstance(ex.exc, exception.ResourceUnknownStatus) @@ -2460,8 +1973,6 @@ class ServersTest(common.HeatTestCase): six.text_type(ex.exc.message)) self.assertEqual((server.SUSPEND, server.FAILED), server.state) - self.m.VerifyAll() - def _test_server_status_resume(self, name, state=('SUSPEND', 'COMPLETE')): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, name) @@ -2469,29 +1980,19 @@ class ServersTest(common.HeatTestCase): server.resource_id = '1234' server.state_set(state[0], state[1]) - def status_suspended(*args): - return_server.status = 'SUSPENDED' + def set_status(status): + return_server.status = status + return return_server - def status_active(*args): - return_server.status = 'ACTIVE' - - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).WithSideEffects( - status_suspended).AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'resume') - return_server.resume().AndReturn(None) - self.fc.servers.get(return_server.id).WithSideEffects( - status_suspended).AndReturn(return_server) - self.fc.servers.get(return_server.id).WithSideEffects( - status_active).AndReturn(return_server) - self.m.ReplayAll() + self.patchobject(return_server, 'resume') + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status('SUSPENDED'), + set_status('SUSPENDED'), + set_status('ACTIVE')]) scheduler.TaskRunner(server.resume)() self.assertEqual((server.RESUME, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_server_resume_in_suspend_complete(self): self._test_server_status_resume( name='test_resume_in_suspend_complete') @@ -2512,8 +2013,6 @@ class ServersTest(common.HeatTestCase): 'srv_susp_norid') server.resource_id = None - self.m.ReplayAll() - server.state_set(server.SUSPEND, server.COMPLETE) ex = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(server.resume)) @@ -2523,18 +2022,14 @@ class ServersTest(common.HeatTestCase): six.text_type(ex)) self.assertEqual((server.RESUME, server.FAILED), server.state) - self.m.VerifyAll() - def test_server_status_resume_not_found(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, 'srv_res_nf') server.resource_id = '1234' - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndRaise( - fakes_nova.fake_exception()) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + side_effect=fakes_nova.fake_exception()) server.state_set(server.SUSPEND, server.COMPLETE) @@ -2545,8 +2040,6 @@ class ServersTest(common.HeatTestCase): six.text_type(ex)) self.assertEqual((server.RESUME, server.FAILED), server.state) - self.m.VerifyAll() - def test_server_status_build_spawning(self): self._test_server_status_not_build_active('BUILD(SPAWNING)') @@ -2583,23 +2076,17 @@ class ServersTest(common.HeatTestCase): 'srv_sts_bld') server.resource_id = '1234' - def status_uncommon(*args): - return_server.status = uncommon_status + def set_status(status): + return_server.status = status + return return_server - def status_active(*args): - return_server.status = 'ACTIVE' - - self.fc.servers.get(server.resource_id).WithSideEffects( - status_uncommon).AndReturn(return_server) - self.fc.servers.get(server.resource_id).WithSideEffects( - status_active).AndReturn(return_server) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', + side_effect=[set_status(uncommon_status), + set_status('ACTIVE')]) scheduler.TaskRunner(server.create)() self.assertEqual((server.CREATE, server.COMPLETE), server.state) - self.m.VerifyAll() - def test_build_nics(self): return_server = self.fc.servers.list()[1] server = self._create_test_server(return_server, @@ -2625,9 +2112,6 @@ class ServersTest(common.HeatTestCase): server._build_nics([{'port': 'aaaabbbb'}, {'fixed_ip': '2002::2'}])) - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') self.assertEqual([{'net-id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}], server._build_nics( [{'network': @@ -2635,37 +2119,44 @@ class ServersTest(common.HeatTestCase): self.patchobject(server, 'is_using_neutron', return_value=False) self.assertEqual([{'net-id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}], - server._build_nics([{'network': 'public'}])) + server._build_nics( + [{'network': + 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}])) - expected = ('Multiple physical resources were found with name (foo)') - exc = self.assertRaises( - exception.PhysicalResourceNameAmbiguity, - server._build_nics, ([{'network': 'foo'}])) - self.assertIn(expected, six.text_type(exc)) - expected = 'The Nova network (bar) could not be found' - exc = self.assertRaises( - exception.EntityNotFound, - server._build_nics, ([{'network': 'bar'}])) - self.assertIn(expected, six.text_type(exc)) + def test_server_network_errors(self): + stack_name = 'net_err' + (tmpl, stack) = self._setup_test_stack(stack_name, + test_templ=ns_template) - self.m.VerifyAll() + side_effect = [neutron.exceptions.NotFound(), + neutron.exceptions.NeutronClientNoUniqueMatch()] + + self.patchobject(neutron.NeutronClientPlugin, + 'find_resourceid_by_name_or_id', + side_effect=side_effect) + resource_defns = tmpl.resource_definitions(stack) + server = servers.Server('server', + resource_defns['server'], stack) + + self.assertRaises(neutron.exceptions.NotFound, + scheduler.TaskRunner(server.create)) + self.assertRaises(neutron.exceptions.NeutronClientNoUniqueMatch, + scheduler.TaskRunner(server.create)) def test_server_without_ip_address(self): return_server = self.fc.servers.list()[3] return_server.id = '9102' server = self._create_test_server(return_server, 'wo_ipaddr') - - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('9102').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().MultipleTimes().AndReturn([]) - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', return_value=return_server) + self.patchobject(return_server, 'interface_list', return_value=[]) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') self.assertEqual({'empty_net': []}, server.FnGetAtt('addresses')) self.assertEqual({'empty_net': []}, server.FnGetAtt('networks')) - self.m.VerifyAll() + self.assertEqual(0, mock_detach.call_count) + self.assertEqual(0, mock_attach.call_count) def test_build_block_device_mapping(self): self.assertIsNone(servers.Server._build_block_device_mapping([])) @@ -2695,7 +2186,9 @@ class ServersTest(common.HeatTestCase): } ])) - def test_validate_block_device_mapping_volume_size_valid_int(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_block_device_mapping_volume_size_valid_int(self, + mock_create): stack_name = 'val_vsize_valid' tmpl, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', @@ -2706,15 +2199,16 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self._mock_validate_flavor_image_success() - self._server_validate_mock(server) - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.stub_VolumeConstraint_validate() self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_validate_block_device_mapping_volume_size_valid_str(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_block_device_mapping_volume_size_valid_str(self, + mock_create): stack_name = 'val_vsize_valid' tmpl, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', @@ -2724,16 +2218,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self._mock_validate_flavor_image_success() - self._server_validate_mock(server) - - self.m.ReplayAll() - + self.stub_VolumeConstraint_validate() + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_validate_block_device_mapping_volume_size_invalid_str(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_bd_mapping_volume_size_invalid_str(self, mock_create): stack_name = 'val_vsize_invalid' tmpl, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', @@ -2743,21 +2236,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.patchobject(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_ImageConstraint_validate() self.stub_VolumeConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn("Value '10a' is not an integer", six.text_type(exc)) - self.m.VerifyAll() - def test_validate_conflict_block_device_mapping_props(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_conflict_block_device_mapping_props(self, mock_create): stack_name = 'val_blkdev1' (tmpl, stack) = self._setup_test_stack(stack_name) - bdm = [{'device_name': 'vdb', 'snapshot_id': '1234', 'volume_id': '1234'}] wsp = tmpl.t['Resources']['WebServer']['Properties'] @@ -2765,21 +2252,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') self.stub_VolumeConstraint_validate() self.stub_SnapshotConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - self.assertRaises(exception.ResourcePropertyConflict, server.validate) - self.m.VerifyAll() - def test_validate_insufficient_block_device_mapping_props(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_insufficient_block_device_mapping_props(self, + mock_create): stack_name = 'val_blkdev2' (tmpl, stack) = self._setup_test_stack(stack_name) - bdm = [{'device_name': 'vdb', 'volume_size': 1, 'delete_on_termination': True}] wsp = tmpl.t['Resources']['WebServer']['Properties'] @@ -2787,21 +2268,14 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - ex = self.assertRaises(exception.StackValidationFailed, server.validate) msg = ("Either volume_id or snapshot_id must be specified " "for device mapping vdb") self.assertEqual(msg, six.text_type(ex)) - self.m.VerifyAll() - - def test_validate_block_device_mapping_with_empty_ref(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_block_device_mapping_with_empty_ref(self, mock_create): stack_name = 'val_blkdev2' (tmpl, stack) = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '', @@ -2812,18 +2286,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.stub_VolumeConstraint_validate() - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - - self.m.ReplayAll() - self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_validate_without_image_or_bootable_volume(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_without_image_or_bootable_volume(self, mock_create): stack_name = 'val_imgvol' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -2834,21 +2305,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) self.stub_VolumeConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - ex = self.assertRaises(exception.StackValidationFailed, server.validate) msg = ('Neither image nor bootable volume is specified ' 'for instance %s' % server.name) self.assertEqual(msg, six.text_type(ex)) - self.m.VerifyAll() - - def test_validate_invalid_image_status(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_invalid_image_status(self, mock_create): stack_name = 'test_stack' tmpl, stack = self._setup_test_stack(stack_name) @@ -2856,23 +2321,17 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_inactive_image', resource_defns['WebServer'], stack) - self._server_validate_mock(server) - image = tmpl['Resources']['WebServer']['Properties']['image'] mock_image = mock.Mock(min_ram=2, status='sdfsdf') - self.m.StubOutWithMock(glance.GlanceClientPlugin, 'get_image') - glance.GlanceClientPlugin.get_image( - image).AndReturn(mock_image) - self.stub_FlavorConstraint_validate() - - self.m.ReplayAll() + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=mock_image) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( 'Image status is required to be active not sdfsdf.', six.text_type(error)) - self.m.VerifyAll() - def test_validate_insufficient_ram_flavor(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_insufficient_ram_flavor(self, mock_create): stack_name = 'test_stack' tmpl, stack = self._setup_test_stack(stack_name) @@ -2880,59 +2339,36 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_insufficient_ram_flavor', resource_defns['WebServer'], stack) - self._server_validate_mock(server) - image = tmpl['Resources']['WebServer']['Properties']['image'] - flavor = tmpl['Resources']['WebServer']['Properties']['flavor'] mock_image = mock.Mock(min_ram=100, status='active') - self.m.StubOutWithMock(glance.GlanceClientPlugin, 'get_image') - glance.GlanceClientPlugin.get_image( - image).AndReturn(mock_image) - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_flavor') - nova.NovaClientPlugin.get_flavor(flavor).MultipleTimes().AndReturn( - self.mock_flavor) - - self.m.ReplayAll() + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( - 'Image F17-x86_64-gold requires 100 minimum ram. Flavor m1.large ' + 'Image F18-x86_64-gold requires 100 minimum ram. Flavor m1.large ' 'has only 4.', six.text_type(error)) - self.m.VerifyAll() - def test_validate_image_flavor_not_found(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_image_flavor_not_found(self, mock_create): stack_name = 'test_stack' tmpl, stack = self._setup_test_stack(stack_name) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('image_not_found', resource_defns['WebServer'], stack) - - self._server_validate_mock(server) - image = tmpl['Resources']['WebServer']['Properties']['image'] - flavor = tmpl['Resources']['WebServer']['Properties']['flavor'] - - self.m.StubOutWithMock(glance.GlanceClientPlugin, 'get_image') - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_flavor') - - self.stub_FlavorConstraint_validate() - # Image not found - glance.GlanceClientPlugin.get_image( - image).AndRaise(glance.exceptions.NotFound()) - - # Flavor not found - glance.GlanceClientPlugin.get_image( - image).AndReturn(self.mock_image) - nova.NovaClientPlugin.get_flavor( - flavor).AndRaise(fakes_nova.fake_exception()) - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + side_effect=[glance.exceptions.NotFound(), + self.mock_image]) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + side_effect=nova.exceptions.NotFound('')) + self.assertIsNone(server.validate()) self.assertIsNone(server.validate()) - self.assertIsNone(server.validate()) - self.m.VerifyAll() - - def test_validate_insufficient_disk_flavor(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_insufficient_disk_flavor(self, mock_create): stack_name = 'test_stack' tmpl, stack = self._setup_test_stack(stack_name) @@ -2940,25 +2376,17 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_insufficient_disk_flavor', resource_defns['WebServer'], stack) - self._server_validate_mock(server) - image = tmpl['Resources']['WebServer']['Properties']['image'] - flavor = tmpl['Resources']['WebServer']['Properties']['flavor'] mock_image = mock.Mock(min_ram=1, status='active', min_disk=100) - self.m.StubOutWithMock(glance.GlanceClientPlugin, 'get_image') - glance.GlanceClientPlugin.get_image( - image).AndReturn(mock_image) - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_flavor') - nova.NovaClientPlugin.get_flavor(flavor).MultipleTimes().AndReturn( - self.mock_flavor) - - self.m.ReplayAll() + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) error = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual( - 'Image F17-x86_64-gold requires 100 GB minimum disk space. ' + 'Image F18-x86_64-gold requires 100 GB minimum disk space. ' 'Flavor m1.large has only 4 GB.', six.text_type(error)) - self.m.VerifyAll() def test_build_block_device_mapping_v2(self): self.assertIsNone(servers.Server._build_block_device_mapping_v2([])) @@ -3000,7 +2428,9 @@ class ServersTest(common.HeatTestCase): {'device_name': ''} ])) - def test_validate_with_both_blk_dev_map_and_blk_dev_map_v2(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_with_both_blk_dev_map_and_blk_dev_map_v2(self, + mock_create): stack_name = 'invalid_stack' tmpl, stack = self._setup_test_stack(stack_name) bdm = [{'device_name': 'vda', 'volume_id': '1234', @@ -3013,22 +2443,16 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') self.stub_VolumeConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - exc = self.assertRaises(exception.ResourcePropertyConflict, server.validate) msg = ('Cannot define the following properties at the same time: ' 'block_device_mapping, block_device_mapping_v2.') self.assertEqual(msg, six.text_type(exc)) - self.m.VerifyAll() - - def test_validate_conflict_block_device_mapping_v2_props(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_conflict_block_device_mapping_v2_props(self, + mock_create): stack_name = 'val_blkdev2' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -3038,18 +2462,12 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') self.stub_VolumeConstraint_validate() - self.stub_FlavorConstraint_validate() self.stub_SnapshotConstraint_validate() - self.m.ReplayAll() - self.assertRaises(exception.ResourcePropertyConflict, server.validate) - self.m.VerifyAll() - def test_validate_without_bootable_source_in_bdm_v2(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_without_bootable_source_in_bdm_v2(self, mock_create): stack_name = 'val_blkdev2' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -3059,21 +2477,14 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - exc = self.assertRaises(exception.StackValidationFailed, server.validate) msg = ('Either volume_id, snapshot_id, image_id or swap_size must ' 'be specified.') self.assertEqual(msg, six.text_type(exc)) - self.m.VerifyAll() - - def test_validate_bdm_v2_properties_success(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_bdm_v2_properties_success(self, mock_create): stack_name = 'v2_properties' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -3084,16 +2495,15 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self._mock_validate_flavor_image_success() - self._server_validate_mock(server) - self.m.ReplayAll() - + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.stub_VolumeConstraint_validate() self.assertIsNone(server.validate()) - self.m.VerifyAll() - - def test_validate_bdm_v2_properties_no_bootable_vol(self): + @mock.patch.object(nova.NovaClientPlugin, '_create') + def test_validate_bdm_v2_properties_no_bootable_vol(self, mock_create): stack_name = 'v2_properties' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -3104,20 +2514,12 @@ class ServersTest(common.HeatTestCase): resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.stub_VolumeConstraint_validate() - self.stub_FlavorConstraint_validate() - self.m.ReplayAll() - exc = self.assertRaises(exception.StackValidationFailed, server.validate) msg = ('Neither image nor bootable volume is specified for instance ' 'server_create_image_err') self.assertEqual(msg, six.text_type(exc)) - self.m.VerifyAll() - def test_validate_metadata_too_many(self): stack_name = 'srv_val_metadata' (tmpl, stack) = self._setup_test_stack(stack_name) @@ -3126,26 +2528,19 @@ class ServersTest(common.HeatTestCase): 'b': 2, 'c': 3, 'd': 4} - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) ex = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertIn('Instance metadata must not contain greater than 3 ' 'entries', six.text_type(ex)) - self.m.VerifyAll() def test_validate_metadata_okay(self): stack_name = 'srv_val_metadata' @@ -3154,27 +2549,22 @@ class ServersTest(common.HeatTestCase): tmpl.t['Resources']['WebServer']['Properties']['metadata'] = {'a': 1, 'b': 2, 'c': 3} - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - - self.m.ReplayAll() + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_too_many_personality(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "fake contents1", "/fake/path2": "fake_contents2", @@ -3186,25 +2576,19 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', return_value=self.limits) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual("The personality property may not contain " "greater than 5 entries.", six.text_type(exc)) - self.m.VerifyAll() def test_server_validate_personality_okay(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "fake contents1", "/fake/path2": "fake_contents2", @@ -3215,43 +2599,31 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', return_value=self.limits) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_personality_file_size_okay(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "a" * 10240} resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', return_value=self.limits) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_server_validate_personality_file_size_too_big(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "a" * 10241} @@ -3259,40 +2631,28 @@ class ServersTest(common.HeatTestCase): server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', return_value=self.limits) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) exc = self.assertRaises(exception.StackValidationFailed, server.validate) self.assertEqual('The contents of personality file "/fake/path1" ' 'is larger than the maximum allowed personality ' 'file size (10240 bytes).', six.text_type(exc)) - self.m.VerifyAll() def test_server_validate_personality_get_attr_return_none(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack( stack_name, server_with_sw_config_personality) + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['server'], stack) - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().MultipleTimes().AndReturn(self.limits) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', return_value=self.limits) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) self.assertIsNone(server.validate()) - self.m.VerifyAll() def test_resolve_attribute_server_not_found(self): return_server = self.fc.servers.list()[1] @@ -3300,33 +2660,25 @@ class ServersTest(common.HeatTestCase): 'srv_resolve_attr') server.resource_id = '1234' - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndRaise( - fakes_nova.fake_exception()) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', + side_effect=fakes_nova.fake_exception()) self.assertEqual('', server._resolve_all_attributes("accessIPv4")) - self.m.VerifyAll() def test_resolve_attribute_console_url(self): server = self.fc.servers.list()[0] tmpl, stack = self._setup_test_stack('console_url_stack') + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) ws = servers.Server( 'WebServer', tmpl.resource_definitions(stack)['WebServer'], stack) ws.resource_id = server.id - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.id).AndReturn(server) - self.m.ReplayAll() - + self.patchobject(self.fc.servers, 'get', return_value=server) console_urls = ws._resolve_all_attributes('console_urls') self.assertIsInstance(console_urls, collections.Mapping) supported_consoles = ('novnc', 'xvpvnc', 'spice-html5', 'rdp-html5', 'serial') self.assertEqual(set(supported_consoles), set(six.iterkeys(console_urls))) - self.m.VerifyAll() def test_resolve_attribute_networks(self): return_server = self.fc.servers.list()[1] @@ -3335,17 +2687,13 @@ class ServersTest(common.HeatTestCase): server.resource_id = '1234' server.networks = {"fake_net": ["10.0.0.3"]} - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(server.resource_id).AndReturn(server) - self.m.StubOutWithMock(nova.NovaClientPlugin, 'get_net_id_by_label') - nova.NovaClientPlugin.get_net_id_by_label( - 'fake_net').AndReturn('fake_uuid') - self.m.ReplayAll() + self.patchobject(self.fc.servers, 'get', return_value=server) + self.patchobject(nova.NovaClientPlugin, 'get_net_id_by_label', + return_value='fake_uuid') expect_networks = {"fake_uuid": ["10.0.0.3"], "fake_net": ["10.0.0.3"]} self.assertEqual(expect_networks, server._resolve_all_attributes("networks")) - self.m.VerifyAll() def test_empty_instance_user(self): """Test Nova server doesn't set instance_user in build_userdata @@ -3357,15 +2705,11 @@ class ServersTest(common.HeatTestCase): return_server = self.fc.servers.list()[1] server = self._setup_test_server(return_server, 'without_user') metadata = server.metadata_get() - self.m.StubOutWithMock(nova.NovaClientPlugin, 'build_userdata') - nova.NovaClientPlugin.build_userdata( - metadata, - 'wordpress', - instance_user=None, - user_data_format='HEAT_CFNTOOLS') - self.m.ReplayAll() + build_data = self.patchobject(nova.NovaClientPlugin, 'build_userdata') scheduler.TaskRunner(server.create)() - self.m.VerifyAll() + build_data.assert_called_with(metadata, 'wordpress', + instance_user=None, + user_data_format='HEAT_CFNTOOLS') def create_old_net(self, port=None, net=None, ip=None, uuid=None, subnet=None, @@ -3400,15 +2744,6 @@ class ServersTest(common.HeatTestCase): return_value='f3ef5d2f-d7ba-4b27-af66-58ca0b81e032') net_id = server._get_network_id(net) self.assertEqual('f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', net_id) - - net = {'network': 'private_net', - 'fixed_ip': '1.2.3.4'} - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='f3ef5d2f-d7ba-4b27-af66-58ca0b81e032') - net_id = server._get_network_id(net) - self.assertEqual('f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', net_id) - net = {'network': '', 'fixed_ip': '1.2.3.4'} net_id = server._get_network_id(net) self.assertIsNone(net_id) @@ -3432,13 +2767,6 @@ class ServersTest(common.HeatTestCase): net_id = server._get_network_id(net) self.assertEqual('f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', net_id) - net = {'network': 'private_net', - 'fixed_ip': '1.2.3.4'} - self.patchobject(nova.NovaClientPlugin, 'get_nova_network_id', - return_value='f3ef5d2f-d7ba-4b27-af66-58ca0b81e032') - net_id = server._get_network_id(net) - self.assertEqual('f3ef5d2f-d7ba-4b27-af66-58ca0b81e032', net_id) - def test_exclude_not_updated_networks_no_matching(self): return_server = self.fc.servers.list()[3] server = self._create_test_server(return_server, 'networks_update') @@ -3601,31 +2929,21 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('9102').MultipleTimes().AndReturn(return_server) + self.patchobject(self.fc.servers, 'get', return_value=return_server) # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().AndReturn([iface]) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) - - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach(new_networks[0]['port'], - None, None).AndReturn(None) - self.stub_PortConstraint_validate() - self.m.ReplayAll() + self.patchobject(return_server, 'interface_list', return_value=[iface]) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(1, mock_detach.call_count) + self.assertEqual(1, mock_attach.call_count) def test_server_update_None_networks_with_network_id(self): return_server = self.fc.servers.list()[3] @@ -3641,35 +2959,22 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('9102').MultipleTimes().AndReturn(return_server) + self.patchobject(self.fc.servers, 'get', return_value=return_server) + # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().AndReturn([iface]) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) - - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach(None, new_networks[0]['network'], - new_networks[0]['fixed_ip']).AndReturn( - None) - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') - self.stub_NetworkConstraint_validate() - self.m.ReplayAll() + self.patchobject(return_server, 'interface_list', return_value=[iface]) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(1, mock_detach.call_count) + self.assertEqual(1, mock_attach.call_count) def test_server_update_empty_networks_with_complex_parameters(self): return_server = self.fc.servers.list()[3] @@ -3682,36 +2987,21 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('9102').MultipleTimes().AndReturn(return_server) + self.patchobject(self.fc.servers, 'get', return_value=return_server) + # to make sure, that old_networks will be None self.assertFalse(hasattr(server.t['Properties'], 'networks')) iface = self.create_fake_iface('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '450abbc9-9b6d-4d6f-8c3a-c47ac34100ef', '1.2.3.4') - self.m.StubOutWithMock(return_server, 'interface_list') - return_server.interface_list().AndReturn([iface]) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa').AndReturn(None) - - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value=None) - - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach( - new_networks[0]['port'], None, None).AndReturn(None) - self.stub_NetworkConstraint_validate() - self.stub_PortConstraint_validate() - self.m.ReplayAll() - + self.patchobject(return_server, 'interface_list', return_value=[iface]) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(1, mock_detach.call_count) + self.assertEqual(1, mock_attach.call_count) def test_server_update_networks_with_complex_parameters(self): return_server = self.fc.servers.list()[1] @@ -3735,11 +3025,7 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = new_networks - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('5678').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') + self.patchobject(self.fc.servers, 'get', return_value=return_server) poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', @@ -3756,29 +3042,14 @@ class ServersTest(common.HeatTestCase): '31.32.33.34') ] - return_server.interface_list().AndReturn(poor_interfaces) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[3].port_id).InAnyOrder().AndReturn(None) - - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach( - new_networks[1]['port'], None, None).AndReturn(None) - self.stub_NetworkConstraint_validate() - self.stub_PortConstraint_validate() - self.m.ReplayAll() - + self.patchobject(return_server, 'interface_list', + return_value=poor_interfaces) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(4, mock_detach.call_count) + self.assertEqual(2, mock_attach.call_count) def test_server_update_networks_with_None(self): return_server = self.fc.servers.list()[1] @@ -3795,12 +3066,7 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = None - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('5678').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') - + self.patchobject(self.fc.servers, 'get', return_value=return_server) poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', @@ -3812,27 +3078,15 @@ class ServersTest(common.HeatTestCase): 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', '31.32.33.34') ] - - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') - return_server.interface_list().AndReturn(poor_interfaces) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[1].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) - - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach(None, None, None).AndReturn(None) - self.m.ReplayAll() + self.patchobject(return_server, 'interface_list', + return_value=poor_interfaces) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(3, mock_detach.call_count) + self.assertEqual(1, mock_attach.call_count) def test_server_update_networks_with_empty_list(self): return_server = self.fc.servers.list()[1] @@ -3849,12 +3103,7 @@ class ServersTest(common.HeatTestCase): update_template = copy.deepcopy(server.t) update_template['Properties']['networks'] = [] - self._stub_glance_for_update() - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get('5678').MultipleTimes().AndReturn(return_server) - - self.m.StubOutWithMock(return_server, 'interface_list') - + self.patchobject(self.fc.servers, 'get', return_value=return_server) poor_interfaces = [ self.create_fake_iface('95e25541-d26a-478d-8f36-ae1c8f6b74dc', 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa', @@ -3867,27 +3116,15 @@ class ServersTest(common.HeatTestCase): '31.32.33.34') ] - self.patchobject(neutron.NeutronClientPlugin, - 'find_resourceid_by_name_or_id', - return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') - - return_server.interface_list().AndReturn(poor_interfaces) - - self.m.StubOutWithMock(return_server, 'interface_detach') - return_server.interface_detach( - poor_interfaces[0].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[1].port_id).InAnyOrder().AndReturn(None) - return_server.interface_detach( - poor_interfaces[2].port_id).InAnyOrder().AndReturn(None) - - self.m.StubOutWithMock(return_server, 'interface_attach') - return_server.interface_attach(None, None, None).AndReturn(None) - self.m.ReplayAll() + self.patchobject(return_server, 'interface_list', + return_value=poor_interfaces) + mock_detach = self.patchobject(return_server, 'interface_detach') + mock_attach = self.patchobject(return_server, 'interface_attach') scheduler.TaskRunner(server.update, update_template)() self.assertEqual((server.UPDATE, server.COMPLETE), server.state) - self.m.VerifyAll() + self.assertEqual(3, mock_detach.call_count) + self.assertEqual(1, mock_attach.call_count) def test_server_properties_validation_create_and_update(self): return_server = self.fc.servers.list()[1] @@ -3898,16 +3135,11 @@ class ServersTest(common.HeatTestCase): 'my_server') update_template = copy.deepcopy(server.t) - update_template['Properties']['image'] = 'Update Image' + update_template['Properties']['image'] = 'F17-x86_64-gold' update_template['Properties']['image_update_policy'] = 'REPLACE' - - # update - self.stub_ImageConstraint_validate() updater = scheduler.TaskRunner(server.update, update_template) self.assertRaises(exception.UpdateReplace, updater) - self.m.VerifyAll() - def test_server_properties_validation_create_and_update_fail(self): return_server = self.fc.servers.list()[1] @@ -3916,24 +3148,18 @@ class ServersTest(common.HeatTestCase): server = self._create_test_server(return_server, 'my_server') - self.m.StubOutWithMock(glance.ImageConstraint, "validate") - # verify that validate gets invoked exactly once for update ex = glance.exceptions.NotFound() - glance.ImageConstraint.validate('Update Image', - mox.IgnoreArg()).AndRaise(ex) - self.m.ReplayAll() - + self.patchobject(glance.GlanceClientPlugin, + 'find_image_by_name_or_id', + side_effect=[1, ex]) update_template = copy.deepcopy(server.t) update_template['Properties']['image'] = 'Update Image' # update updater = scheduler.TaskRunner(server.update, update_template) - err = self.assertRaises(exception.ResourceFailure, updater) - self.assertEqual('StackValidationFailed: resources.my_server: ' - 'Property error: ' - 'WebServer.Properties.image: Not Found (HTTP 404)', + err = self.assertRaises(glance.exceptions.NotFound, updater) + self.assertEqual('Not Found (HTTP 404)', six.text_type(err)) - self.m.VerifyAll() def test_server_snapshot(self): return_server = self.fc.servers.list()[1] @@ -3946,15 +3172,17 @@ class ServersTest(common.HeatTestCase): self.assertEqual({'snapshot_image_id': '456'}, resource_data_object.ResourceData.get_all(server)) - self.m.VerifyAll() def test_server_check_snapshot_complete_image_in_deleted(self): - self.test_server_check_snapshot_complete_fail(image_status='DELETED') + self._test_server_check_snapshot_complete(image_status='DELETED') def test_server_check_snapshot_complete_image_in_error(self): - self.test_server_check_snapshot_complete_fail() + self._test_server_check_snapshot_complete() - def test_server_check_snapshot_complete_fail(self, image_status='ERROR'): + def test_server_check_snapshot_complete_fail(self): + self._test_server_check_snapshot_complete() + + def _test_server_check_snapshot_complete(self, image_status='ERROR'): return_server = self.fc.servers.list()[1] return_server.id = '1234' server = self._create_test_server(return_server, @@ -3969,131 +3197,85 @@ class ServersTest(common.HeatTestCase): # test snapshot_image_id already set to resource data self.assertEqual({'snapshot_image_id': '456'}, resource_data_object.ResourceData.get_all(server)) - self.m.VerifyAll() def test_server_dont_validate_personality_if_personality_isnt_set(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) - resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - # We mock out nova.NovaClientPlugin.absolute_limits but we don't - # specify how this mock should behave, so mox will verify that this - # mock is NOT called during call to server.validate(). - # This is the way to validate that no excessive calls to Nova - # are made during validation. - self.m.StubOutWithMock(nova.NovaClientPlugin, 'absolute_limits') - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - self.m.ReplayAll() + self.patchobject(nova.NovaClientPlugin, 'get_flavor', + return_value=self.mock_flavor) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) + mock_limits = self.patchobject(nova.NovaClientPlugin, + 'absolute_limits') + self.patchobject(nova.NovaClientPlugin, '_create') # Assert here checks that server resource validates, but actually # this call is Act stage of this test. We calling server.validate() # to verify that no excessive calls to Nova are made during validation. self.assertIsNone(server.validate()) - self.m.VerifyAll() + # Check nova.NovaClientPlugin.absolute_limits is not called during + # call to server.validate() + self.assertFalse(mock_limits.called) def test_server_validate_connection_error_retry_successful(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "a" * 10} - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().AndRaise(requests.ConnectionError()) - self.fc.limits.get().AndReturn(self.limits) - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', + side_effect=[requests.ConnectionError(), + self.limits]) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) self.assertIsNone(server.validate()) - self.m.VerifyAll() - def test_server_validate_connection_error_retry_failure(self): stack_name = 'srv_val' (tmpl, stack) = self._setup_test_stack(stack_name) tmpl.t['Resources']['WebServer']['Properties'][ 'personality'] = {"/fake/path1": "a" * 10} - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) resource_defns = tmpl.resource_definitions(stack) server = servers.Server('server_create_image_err', resource_defns['WebServer'], stack) - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().AndReturn(self.fc) - self._mock_get_image_id_success('F17-x86_64-gold', 'image_id') - self._mock_validate_flavor_image_success() - - self.m.StubOutWithMock(self.fc.limits, 'get') - self.fc.limits.get().AndRaise(requests.ConnectionError()) - self.fc.limits.get().AndRaise(requests.ConnectionError()) - self.fc.limits.get().AndRaise(requests.ConnectionError()) - self.m.ReplayAll() - + self.patchobject(self.fc.limits, 'get', + side_effect=[requests.ConnectionError(), + requests.ConnectionError(), + requests.ConnectionError()]) + self.patchobject(glance.GlanceClientPlugin, 'get_image', + return_value=self.mock_image) self.assertRaises(requests.ConnectionError, server.validate) - self.m.VerifyAll() - def test_server_restore(self): t = template_format.parse(ns_template) tmpl = template.Template(t, files={'a_file': 'the content'}) stack = parser.Stack(utils.dummy_context(), "server_restore", tmpl) stack.store() - - self.m.StubOutWithMock(nova.NovaClientPlugin, '_create') - nova.NovaClientPlugin._create().MultipleTimes().AndReturn(self.fc) - + self.patchobject(nova.NovaClientPlugin, '_create', + return_value=self.fc) self.patchobject(stack['server'], 'store_external_ports') - return_server = self.fc.servers.list()[1] return_server.id = '1234' - - self.m.StubOutWithMock(self.fc.servers, 'create') - self.fc.servers.create( - image=744, flavor=3, key_name=None, - name=utils.PhysName("server_restore", "server"), - nics=[{'net-id': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'}], - security_groups=[], - userdata=mox.IgnoreArg(), scheduler_hints=None, - meta=None, availability_zone=None, - block_device_mapping=None, block_device_mapping_v2=None, - config_drive=None, disk_config=None, reservation_id=None, - files={}, admin_pass=None).AndReturn(return_server) - self.m.StubOutWithMock(self.fc.servers, 'get') - self.fc.servers.get(return_server.id).AndReturn(return_server) - - self.m.StubOutWithMock(glance.GlanceClientPlugin, - 'find_image_by_name_or_id') - glance.GlanceClientPlugin.find_image_by_name_or_id( - 'F17-x86_64-gold').MultipleTimes().AndReturn(744) - glance.GlanceClientPlugin.find_image_by_name_or_id( - 'CentOS 5.2').MultipleTimes().AndReturn(1) - + mock_create = self.patchobject(self.fc.servers, 'create', + return_value=return_server) + self.patchobject(self.fc.servers, 'get', + side_effect=[return_server, None]) self.patchobject(neutron.NeutronClientPlugin, 'find_resourceid_by_name_or_id', return_value='aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa') - self.stub_NetworkConstraint_validate() - self.fc.servers.get(return_server.id).AndReturn(return_server) - self.fc.servers.get(return_server.id).AndReturn(return_server) - self.patchobject(return_server, 'get', return_value=None) - - self.m.ReplayAll() - scheduler.TaskRunner(stack.create)() - + self.assertEqual(1, mock_create.call_count) self.assertEqual((stack.CREATE, stack.COMPLETE), stack.state) scheduler.TaskRunner(stack.snapshot, None)() @@ -4107,11 +3289,8 @@ class ServersTest(common.HeatTestCase): 'Snapshot', ('data', 'stack_id'))(data, stack.id) stack.restore(fake_snapshot) - self.assertEqual((stack.RESTORE, stack.COMPLETE), stack.state) - self.m.VerifyAll() - def test_snapshot_policy(self): t = template_format.parse(wp_template) t['Resources']['WebServer']['DeletionPolicy'] = 'Snapshot' @@ -4125,10 +3304,6 @@ class ServersTest(common.HeatTestCase): mock_plugin = self.patchobject(nova.NovaClientPlugin, '_create') mock_plugin.return_value = self.fc - get_image = self.patchobject(glance.GlanceClientPlugin, - 'find_image_by_name_or_id') - get_image.return_value = 744 - return_server = self.fc.servers.list()[1] return_server.id = '1234' @@ -4151,8 +3326,6 @@ class ServersTest(common.HeatTestCase): scheduler.TaskRunner(stack.delete)() self.assertEqual((stack.DELETE, stack.COMPLETE), stack.state) - - get_image.assert_called_with('F17-x86_64-gold') create_image.assert_called_once_with( '1234', utils.PhysName('snapshot_policy', 'WebServer')) @@ -4171,13 +3344,8 @@ class ServersTest(common.HeatTestCase): mock_plugin = self.patchobject(nova.NovaClientPlugin, '_create') mock_plugin.return_value = self.fc - get_image = self.patchobject(glance.GlanceClientPlugin, - 'find_image_by_name_or_id') - get_image.return_value = 744 - return_server = self.fc.servers.list()[1] return_server.id = '1234' - mock_create = self.patchobject(self.fc.servers, 'create') mock_create.return_value = return_server mock_get = self.patchobject(self.fc.servers, 'get') @@ -4209,8 +3377,6 @@ class ServersTest(common.HeatTestCase): self.assertEqual( 'Resource DELETE failed: Error: resources.WebServer: ERROR', stack.status_reason) - - get_image.assert_called_with('F17-x86_64-gold') create_image.assert_called_once_with( '1234', utils.PhysName('snapshot_policy', 'WebServer')) @@ -4290,7 +3456,7 @@ class ServersTest(common.HeatTestCase): class ServerInternalPortTest(common.HeatTestCase): def setUp(self): super(ServerInternalPortTest, self).setUp() - self.resolve = self.patchobject(neutronV20, + self.resolve = self.patchobject(neutron.NeutronClientPlugin, 'find_resourceid_by_name_or_id') self.port_create = self.patchobject(neutronclient.Client, 'create_port') @@ -4299,6 +3465,26 @@ class ServerInternalPortTest(common.HeatTestCase): self.port_show = self.patchobject(neutronclient.Client, 'show_port') + def flavor_side_effect(*args): + return 2 if args[0] == 'm1.small' else 1 + + def image_side_effect(*args): + return 2 if args[0] == 'F17-x86_64-gold' else 1 + + def neutron_side_effect(*args): + if args[0] == 'subnet': + return '1234' + if args[0] == 'network': + return '4321' + if args[0] == 'port': + return '12345' + + self.patchobject(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + side_effect=flavor_side_effect) + self.patchobject(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + side_effect=image_side_effect) + self.resolve.side_effect = neutron_side_effect + def _return_template_stack_and_rsrc_defn(self, stack_name, temp): templ = template.Template(template_format.parse(temp), env=environment.Environment( @@ -4330,8 +3516,6 @@ class ServerInternalPortTest(common.HeatTestCase): create_internal_port = self.patchobject(server, '_create_internal_port', return_value='12345') - self.resolve.return_value = '4321' - networks = [{'port': '12345', 'network': '4321'}] nics = server._build_nics(networks) self.assertEqual([{'port-id': '12345', 'net-id': '4321'}], nics) @@ -4352,7 +3536,6 @@ class ServerInternalPortTest(common.HeatTestCase): """ t, stack, server = self._return_template_stack_and_rsrc_defn('test', tmpl) - networks = server.properties['networks'] for network in networks: # validation passes at validate time @@ -4361,8 +3544,6 @@ class ServerInternalPortTest(common.HeatTestCase): self.patchobject(neutron.NeutronClientPlugin, 'network_id_from_subnet_id', return_value='not_this_network') - self.resolve.return_value = '4321' - ex = self.assertRaises(exception.StackValidationFailed, server._build_nics, networks) self.assertEqual('Specified subnet 1234 does not belongs to ' @@ -4385,8 +3566,6 @@ class ServerInternalPortTest(common.HeatTestCase): t, stack, server = self._return_template_stack_and_rsrc_defn('test', tmpl) - - self.resolve.side_effect = ['4321', '4321', '1234'] self.patchobject(server, '_validate_belonging_subnet_to_net') self.port_create.return_value = {'port': {'id': '111222'}} data_set = self.patchobject(resource.Resource, 'data_set') @@ -4408,8 +3587,6 @@ class ServerInternalPortTest(common.HeatTestCase): def test_build_nics_do_not_create_internal_port(self): t, stack, server = self._return_template_stack_and_rsrc_defn( 'test', tmpl_server_with_network_id) - - self.resolve.side_effect = ['4321', '1234'] self.port_create.return_value = {'port': {'id': '111222'}} data_set = self.patchobject(resource.Resource, 'data_set') @@ -4443,9 +3620,6 @@ class ServerInternalPortTest(common.HeatTestCase): t, stack, server = self._return_template_stack_and_rsrc_defn('test', tmpl) - - self.resolve.side_effect = ['4321', '1234'] - network = {'network': '4321', 'subnet': '1234', 'fixed_ip': '127.0.0.1', 'port_extra_properties': { @@ -4457,7 +3631,6 @@ class ServerInternalPortTest(common.HeatTestCase): ] }} kwargs = server._prepare_internal_port_kwargs(network) - self.assertEqual({'network_id': '4321', 'fixed_ips': [ {'ip_address': '127.0.0.1', 'subnet_id': '1234'} @@ -4478,26 +3651,18 @@ class ServerInternalPortTest(common.HeatTestCase): flavor: m1.small image: F17-x86_64-gold networks: - - subnet: 4321 + - subnet: 1234 """ t, stack, server = self._return_template_stack_and_rsrc_defn('test', tmpl) - self.patchobject(neutron.NeutronClientPlugin, 'network_id_from_subnet_id', - return_value='1234') - self.resolve.return_value = '4321' - - net = {'subnet': '4321'} + return_value='4321') + net = {'subnet': '1234'} net_id = server._get_network_id(net) - self.assertEqual('1234', net_id) - subnet_id = server._get_subnet_id(net) - self.assertEqual('4321', subnet_id) - # check that networks doesn't changed in _get_subnet_id method. - self.assertEqual({'subnet': '4321'}, net) - - self.resolve.return_value = '4321' + self.assertEqual('4321', net_id) + self.assertEqual({'subnet': '1234'}, net) self.port_create.return_value = {'port': {'id': '111222'}} data_set = self.patchobject(resource.Resource, 'data_set') @@ -4506,9 +3671,9 @@ class ServerInternalPortTest(common.HeatTestCase): self.port_create.assert_called_once_with( {'port': {'name': 'server-port-0', - 'network_id': '1234', + 'network_id': '4321', 'fixed_ips': [{ - 'subnet_id': '4321' + 'subnet_id': '1234' }]}}) data_set.assert_called_once_with('internal_ports', '[{"id": "111222"}]') diff --git a/heat/tests/test_metadata_refresh.py b/heat/tests/test_metadata_refresh.py index a183836187..ae86269009 100644 --- a/heat/tests/test_metadata_refresh.py +++ b/heat/tests/test_metadata_refresh.py @@ -15,6 +15,8 @@ from oslo_serialization import jsonutils from heat.common import identifier from heat.common import template_format +from heat.engine.clients.os import glance +from heat.engine.clients.os import nova from heat.engine import environment from heat.engine.resources.aws.cfn.wait_condition_handle import ( WaitConditionHandle) @@ -144,11 +146,13 @@ resources: class MetadataRefreshTest(common.HeatTestCase): + @mock.patch.object(nova.NovaClientPlugin, 'find_flavor_by_name_or_id') + @mock.patch.object(glance.GlanceClientPlugin, 'find_image_by_name_or_id') @mock.patch.object(instance.Instance, 'handle_create') @mock.patch.object(instance.Instance, 'check_create_complete') @mock.patch.object(instance.Instance, 'FnGetAtt') - def test_FnGetAtt_metadata_updated(self, mock_get, - mock_check, mock_handle): + def test_FnGetAtt_metadata_updated(self, mock_get, mock_check, + mock_handle, *args): """Tests that metadata gets updated when FnGetAtt return changes.""" # Setup temp = template_format.parse(TEST_TEMPLATE_METADATA) @@ -158,9 +162,7 @@ class MetadataRefreshTest(common.HeatTestCase): stack = stk.Stack(ctx, 'test_stack', template, disable_rollback=True) stack.store() - self.stub_ImageConstraint_validate() self.stub_KeypairConstraint_validate() - self.stub_FlavorConstraint_validate() # Configure FnGetAtt to return different values on subsequent calls mock_get.side_effect = [ @@ -208,13 +210,15 @@ class WaitConditionMetadataUpdateTest(common.HeatTestCase): self.man = service.EngineService('a-host', 'a-topic') self.man.create_periodic_tasks() + @mock.patch.object(nova.NovaClientPlugin, 'find_flavor_by_name_or_id') + @mock.patch.object(glance.GlanceClientPlugin, 'find_image_by_name_or_id') @mock.patch.object(instance.Instance, 'handle_create') @mock.patch.object(instance.Instance, 'check_create_complete') @mock.patch.object(instance.Instance, 'is_service_available') @mock.patch.object(TaskRunner, '_sleep') @mock.patch.object(WaitConditionHandle, 'identifier') def test_wait_metadata(self, mock_identifier, mock_sleep, mock_available, - mock_check, mock_handle): + mock_check, mock_handle, *args): """Tests a wait condition metadata update after a signal call.""" # Setup Stack @@ -224,9 +228,7 @@ class WaitConditionMetadataUpdateTest(common.HeatTestCase): stack = stk.Stack(ctx, 'test-stack', template, disable_rollback=True) stack.store() - self.stub_ImageConstraint_validate() self.stub_KeypairConstraint_validate() - self.stub_FlavorConstraint_validate() res_id = identifier.ResourceIdentifier('test_tenant_id', stack.name, stack.id, '', 'WH') @@ -288,10 +290,15 @@ class WaitConditionMetadataUpdateTest(common.HeatTestCase): class MetadataRefreshServerTest(common.HeatTestCase): + @mock.patch.object(nova.NovaClientPlugin, 'find_flavor_by_name_or_id', + return_value=1) + @mock.patch.object(glance.GlanceClientPlugin, 'find_image_by_name_or_id', + return_value=1) @mock.patch.object(Server, 'handle_create') @mock.patch.object(Server, 'check_create_complete') @mock.patch.object(Server, 'FnGetAtt') - def test_FnGetAtt_metadata_update(self, mock_get, mock_check, mock_handle): + def test_FnGetAtt_metadata_update(self, mock_get, mock_check, + mock_handle, *args): temp = template_format.parse(TEST_TEMPLATE_SERVER) template = tmpl.Template(temp, env=environment.Environment({})) @@ -299,9 +306,7 @@ class MetadataRefreshServerTest(common.HeatTestCase): stack = stk.Stack(ctx, 'test-stack', template, disable_rollback=True) stack.store() - self.stub_ImageConstraint_validate() self.stub_KeypairConstraint_validate() - self.stub_FlavorConstraint_validate() # Note dummy addresses are from TEST-NET-1 ref rfc5737 mock_get.side_effect = ['192.0.2.1', '192.0.2.2', '192.0.2.2']