def test_delete_non_empty_allowed_ignores_not_found(self): container_name = utils.PhysName('test_stack', 'test_resource') sc.Connection.put_container( container_name, {}).AndReturn(None) sc.Connection.get_container( container_name).AndReturn(({'name': container_name}, [{'name': 'test_object'}])) sc.Connection.delete_object( container_name, 'test_object').AndRaise( sc.ClientException('Object is gone', http_status=404)) sc.Connection.delete_container( container_name).AndRaise( sc.ClientException('Container is gone', http_status=404)) self.m.ReplayAll() t = template_format.parse(swift_template) t['Resources']['SwiftContainer']['Properties']['PurgeOnDelete'] = True stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'SwiftContainer') scheduler.TaskRunner(rsrc.delete)() self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll()
def test_scaling_group_update_replace(self): t = template_format.parse(as_template) stack = utils.parse_stack(t, params=self.params) self._stub_lb_reload(1) now = timeutils.utcnow() self._stub_meta_expected(now, 'ExactCapacity : 1') self._stub_create(1) self.m.ReplayAll() rsrc = self.create_scaling_group(t, stack, 'WebServerGroup') self.assertEqual(utils.PhysName(stack.name, rsrc.name), rsrc.FnGetRefId()) self.assertEqual(1, len(grouputils.get_member_names(rsrc))) props = copy.copy(rsrc.properties.data) props['AvailabilityZones'] = ['foo'] update_snippet = rsrc_defn.ResourceDefinition(rsrc.name, rsrc.type(), props) updater = scheduler.TaskRunner(rsrc.update, update_snippet) self.assertRaises(resource.UpdateReplace, updater) rsrc.delete() self.m.VerifyAll()
def test_delete_conflict_empty(self): container_name = utils.PhysName('test_stack', 'test_resource') sc.Connection.put_container( container_name, { 'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username' }).AndReturn(None) sc.Connection.delete_container(container_name).AndRaise( sc.ClientException('Conflict', http_status=409)) sc.Connection.get_container(container_name).AndReturn(({ 'name': container_name }, [])) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') deleter = scheduler.TaskRunner(rsrc.delete) ex = self.assertRaises(exception.ResourceFailure, deleter) self.assertIn("Conflict", six.text_type(ex)) self.m.VerifyAll()
def test_user_access_allowed(self): self.m.StubOutWithMock(user.User, 'keystone') user.User.keystone().MultipleTimes().AndReturn(self.fc) self.m.StubOutWithMock(user.AccessPolicy, 'access_allowed') user.AccessPolicy.access_allowed('a_resource').AndReturn(True) user.AccessPolicy.access_allowed('b_resource').AndReturn(False) self.m.ReplayAll() t = template_format.parse(user_policy_template) stack = utils.parse_stack(t) rsrc = self.create_user(t, stack, 'CfnUser') self.assertEqual(self.fc.user_id, rsrc.resource_id) self.assertEqual(utils.PhysName('test_stack', 'CfnUser'), rsrc.FnGetRefId()) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertTrue(rsrc.access_allowed('a_resource')) self.assertFalse(rsrc.access_allowed('b_resource')) self.m.VerifyAll()
def test_delete_non_empty_not_allowed(self, mock_put, mock_get): # Setup stack = utils.parse_stack(self.t) container_name = utils.PhysName(stack.name, 'test_resource') mock_get.return_value = ({ 'name': container_name }, [{ 'name': 'test_object' }]) # Test container = self._create_container(stack) runner = scheduler.TaskRunner(container.delete) ex = self.assertRaises(exception.ResourceFailure, runner) # Verify self.assertEqual((container.DELETE, container.FAILED), container.state) self.assertIn( 'ResourceActionNotSupported: resources.test_resource: ' 'Deleting non-empty container', six.text_type(ex)) mock_put.assert_called_once_with(container_name, {}) mock_get.assert_called_once_with(container_name)
def test_delete_conflict_not_empty(self): t = template_format.parse(swift_template) stack = utils.parse_stack(t) container_name = utils.PhysName(stack.name, 'test_resource') sc.Connection.put_container( container_name, {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username'}).AndReturn(None) sc.Connection.delete_container(container_name).AndRaise( sc.ClientException('Not empty', http_status=409)) sc.Connection.get_container(container_name).AndReturn( ({'name': container_name}, [{'name': 'test_object'}])) self.m.ReplayAll() rsrc = self.create_resource(t, stack, 'S3Bucket') deleter = scheduler.TaskRunner(rsrc.delete) ex = self.assertRaises(exception.ResourceFailure, deleter) self.assertIn("ResourceActionNotSupported: resources.test_resource: " "The bucket you tried to delete is not empty", six.text_type(ex)) self.m.VerifyAll()
def test_security_groups_empty_list(self): port_prop = { 'network_id': u'net1234', 'security_groups': [], 'fixed_ips': [{ 'subnet_id': u'sub1234', 'ip_address': u'10.0.3.21' }], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp' } self._mock_create_with_security_groups(port_prop) t = template_format.parse(neutron_port_template) t['resources']['port']['properties']['security_groups'] = [] stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll()
def test_security_groups_empty_list(self): t = template_format.parse(neutron_port_template) t['resources']['port']['properties']['security_groups'] = [] stack = utils.parse_stack(t) port_prop = { 'network_id': u'net_or_sub', 'security_groups': [], 'fixed_ips': [{ 'subnet_id': u'net_or_sub', 'ip_address': u'10.0.3.21' }], 'name': utils.PhysName(stack.name, 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp' } self._mock_create_with_props() port = stack['port'] scheduler.TaskRunner(port.create)() self.assertEqual((port.CREATE, port.COMPLETE), port.state) self.create_mock.assert_called_once_with({'port': port_prop})
def test_port_with_dns_name(self): t = template_format.parse(neutron_port_template) t['resources']['port']['properties']['dns_name'] = 'myvm' stack = utils.parse_stack(t) port_prop = { 'network_id': u'net1234', 'dns_name': 'myvm', 'fixed_ips': [{ 'subnet_id': u'sub1234', 'ip_address': u'10.0.3.21' }], 'name': utils.PhysName(stack.name, 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp' } self._mock_create_with_props(port_prop) port = stack['port'] scheduler.TaskRunner(port.create)() self.assertEqual('my-vm.openstack.org.', port.FnGetAtt('dns_assignment')['fqdn']) self.m.VerifyAll()
def test_create_failed(self): snippet = template_format.parse(pool_template) self.stack = utils.parse_stack(snippet) pool_create_snippet = { 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName(self.stack.name, 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True } } self.mock_create.side_effect = exceptions.NeutronClientException() resource_defns = self.stack.t.resource_definitions(self.stack) rsrc = loadbalancer.Pool('pool', resource_defns['pool'], self.stack) error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'NeutronClientException: resources.pool: ' 'An unknown exception occurred.', six.text_type(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.mock_create.assert_called_once_with(pool_create_snippet)
def test_volume_create_error(self): fv = FakeVolume('creating', 'error') stack_name = 'test_volume_create_error_stack' # create script clients.OpenStackClients.cinder().AndReturn(self.cinder_fc) vol_name = utils.PhysName(stack_name, 'DataVolume') self.cinder_fc.volumes.create(size=u'1', availability_zone='nova', display_description=vol_name, display_name=vol_name).AndReturn(fv) self.m.ReplayAll() t = template_format.parse(volume_template) t['Resources']['DataVolume']['Properties']['AvailabilityZone'] = 'nova' stack = parse_stack(t, stack_name=stack_name) rsrc = vol.Volume('DataVolume', t['Resources']['DataVolume'], stack) create = scheduler.TaskRunner(rsrc.create) self.assertRaises(exception.ResourceFailure, create) self.m.VerifyAll()
def test_create_from_snapshot(self): stack_name = 'test_volume_create_from_snapshot_stack' fv = vt_base.FakeVolume('restoring-backup') fvbr = vt_base.FakeBackupRestore('vol-123') # create script cinder.CinderClientPlugin._create.return_value = self.cinder_fc self.m_restore.return_value = fvbr fv2 = vt_base.FakeVolume('available') self.cinder_fc.volumes.get.side_effect = [fv, fv2] vol_name = utils.PhysName(stack_name, 'DataVolume') self.t['Resources']['DataVolume']['Properties'][ 'SnapshotId'] = 'backup-123' stack = utils.parse_stack(self.t, stack_name=stack_name) self.create_volume(self.t, stack, 'DataVolume', no_create=True) cinder.CinderClientPlugin._create.assert_called_once_with() self.m_restore.assert_called_once_with('backup-123') self.cinder_fc.volumes.get.assert_called_with('vol-123') self.cinder_fc.volumes.update.assert_called_once_with( 'vol-123', description=vol_name, name=vol_name)
def test_attributes(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) container_name = utils.PhysName('test_stack', 'test_resource') swiftclient.Connection.put_container( container_name, {'X-Container-Write': 'test_tenant:test_username', 'X-Container-Read': 'test_tenant:test_username'} ).AndReturn(None) swiftclient.Connection.get_auth().MultipleTimes().AndReturn( ('http://localhost:8080/v_2', None)) swiftclient.Connection.delete_container(container_name).AndReturn(None) self.m.ReplayAll() t = template_format.parse(swift_template) stack = utils.parse_stack(t) rsrc = self.create_resource(t, stack, 'S3Bucket') ref_id = rsrc.FnGetRefId() self.assertEqual(container_name, ref_id) self.assertEqual('localhost', rsrc.FnGetAtt('DomainName')) url = 'http://localhost:8080/v_2/%s' % ref_id self.assertEqual(url, rsrc.FnGetAtt('WebsiteURL')) try: rsrc.FnGetAtt('Foo') raise Exception('Expected InvalidTemplateAttribute') except exception.InvalidTemplateAttribute: pass self.assertRaises(resource.UpdateReplace, rsrc.handle_update, {}, {}, {}) rsrc.delete() self.m.VerifyAll()
def setup_mocks(mocks, stack, mock_image_constraint=True, mock_keystone=True): fc = fakes_nova.FakeClient() mocks.StubOutWithMock(instances.Instance, 'client') instances.Instance.client().MultipleTimes().AndReturn(fc) mocks.StubOutWithMock(nova.NovaClientPlugin, '_create') nova.NovaClientPlugin._create().AndReturn(fc) instance = stack['WebServer'] metadata = instance.metadata_get() if mock_image_constraint: setup_mock_for_image_constraint(mocks, instance.t['Properties']['ImageId']) if mock_keystone: setup_keystone_mocks(mocks, stack) user_data = instance.properties['UserData'] server_userdata = instance.client_plugin().build_userdata( metadata, user_data, 'ec2-user') mocks.StubOutWithMock(nova.NovaClientPlugin, 'build_userdata') nova.NovaClientPlugin.build_userdata(metadata, instance.t['Properties']['UserData'], 'ec2-user').AndReturn(server_userdata) mocks.StubOutWithMock(fc.servers, 'create') fc.servers.create(image=744, flavor=3, key_name='test', name=utils.PhysName(stack.name, 'WebServer'), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None).AndReturn( fc.servers.list()[4]) return fc
def test_missing_mac_address(self): neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'network', 'abcd1234').MultipleTimes().AndReturn('abcd1234') neutronclient.Client.create_port({ 'port': { 'network_id': u'abcd1234', 'allowed_address_pairs': [{ 'ip_address': u'10.0.3.21', }], 'name': utils.PhysName('test_stack', 'port'), 'admin_state_up': True } }).AndReturn({ 'port': { "status": "BUILD", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" } }) neutronclient.Client.show_port( 'fc68ea2c-b60b-4b4f-bd82-94ec81110766').AndReturn({ 'port': { "status": "ACTIVE", "id": "fc68ea2c-b60b-4b4f-bd82-94ec81110766" } }) self.m.ReplayAll() t = template_format.parse(neutron_port_with_address_pair_template) t['resources']['port']['properties']['allowed_address_pairs'][0].pop( 'mac_address') stack = utils.parse_stack(t) port = stack['port'] scheduler.TaskRunner(port.create)() self.m.VerifyAll()
def test_ipv6_subnet(self): t = template_format.parse(neutron_template) props = t['resources']['sub_net']['properties'] props.pop('allocation_pools') props.pop('host_routes') props['ip_version'] = 6 props['ipv6_address_mode'] = 'slaac' props['ipv6_ra_mode'] = 'slaac' props['cidr'] = 'fdfa:6a50:d22b::/64' props['dns_nameservers'] = ['2001:4860:4860::8844'] stack = utils.parse_stack(t) create_info = { 'subnet': { 'name': utils.PhysName(stack.name, 'test_subnet'), 'network_id': 'fc68ea2c-b60b-4b4f-bd82-94ec81110766', 'dns_nameservers': [u'2001:4860:4860::8844'], 'ip_version': 6, 'enable_dhcp': True, 'cidr': u'fdfa:6a50:d22b::/64', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'ipv6_address_mode': 'slaac', 'ipv6_ra_mode': 'slaac' } } subnet_info = copy.deepcopy(create_info) subnet_info['subnet']['id'] = "91e47a57-7508-46fe-afc9-fc454e8580e1" self.create_mock.return_value = subnet_info self.patchobject(stack['net'], 'FnGetRefId', return_value='fc68ea2c-b60b-4b4f-bd82-94ec81110766') rsrc = self.create_subnet(t, stack, 'sub_net') scheduler.TaskRunner(rsrc.create)() self.create_mock.assert_called_once_with(create_info) self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) rsrc.validate()
def test_create_failed_error_status(self): cfg.CONF.set_override('action_retry_limit', 0) neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123' ).AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ERROR', 'name': '5678'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) rsrc = loadbalancer.Pool( 'pool', resource_defns['pool'], stack) self.m.ReplayAll() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'ResourceInError: Went to status ERROR due to "error in pool"', six.text_type(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll()
def create_pool(self, with_vip_subnet=False): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) stvipvsn = { 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub9999', 'pool_id': '5678', 'protocol_port': 80} } stvippsn = copy.deepcopy(stvipvsn) stvippsn['vip']['subnet_id'] = 'sub123' if with_vip_subnet: neutronclient.Client.create_vip(stvipvsn ).AndReturn({'vip': {'id': 'xyz'}}) snippet = template_format.parse(pool_template_with_vip_subnet) else: neutronclient.Client.create_vip(stvippsn ).AndReturn({'vip': {'id': 'xyz'}}) snippet = template_format.parse(pool_template) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) stack = utils.parse_stack(snippet) return loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack)
def _setup_test_instance(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(instance_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=uuidutils.generate_uuid()) t['Resources']['WebServer']['Properties']['Tags'] = intags instance = instances.Instance(stack_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(instance, 'nova') instance.nova().MultipleTimes().AndReturn(self.fc) instance.t = instance.stack.resolve_runtime_data(instance.t) # need to resolve the template functions server_userdata = nova_utils.build_userdata( instance, instance.t['Properties']['UserData']) instance.mime_string = server_userdata self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create(image=1, flavor=1, key_name='test', name=utils.PhysName(stack_name, instance.name), security_groups=None, userdata=server_userdata, scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return instance
def test_create_with_session_persistence(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutron_utils.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123' ).AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80, 'session_persistence': { 'type': 'APP_COOKIE', 'cookie_name': 'cookie'}}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) snippet = template_format.parse(pool_with_session_persistence_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) rsrc = loadbalancer.Pool( 'pool', resource_defns['pool'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll()
def _setup_test_server(self, return_server, name, image_id=None, override_name=False, stub_create=True): stack_name = '%s_s' % name (t, stack) = self._setup_test_stack(stack_name) t['Resources']['WebServer']['Properties']['image'] = \ image_id or 'CentOS 5.2' t['Resources']['WebServer']['Properties']['flavor'] = \ '256 MB Server' server_name = '%s' % name if override_name: t['Resources']['WebServer']['Properties']['name'] = \ server_name server = servers.Server(server_name, t['Resources']['WebServer'], stack) self.m.StubOutWithMock(server, 'nova') server.nova().MultipleTimes().AndReturn(self.fc) server.t = server.stack.resolve_runtime_data(server.t) 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=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=None, nics=None, availability_zone=None, block_device_mapping=None, config_drive=None, disk_config=None, reservation_id=None).AndReturn( return_server) return server
def test_create_failed_unexpected_status(self): clients.OpenStackClients.keystone().AndReturn( fakes.FakeKeystoneClient()) neutron_utils.neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123' ).AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'ERROR', 'name': '5678'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) rsrc = loadbalancer.Pool( 'pool', snippet['Resources']['pool'], stack) self.m.ReplayAll() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual( 'Error: neutron reported unexpected pool ' 'resource[5678] status[ERROR]', str(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll()
def mock_create_route_table(self): self.rt_name = utils.PhysName('test_stack', 'the_route_table') neutronclient.Client.create_router({ 'router': { 'name': self.rt_name } }).AndReturn({ 'router': { 'status': 'BUILD', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) neutronclient.Client.show_router('ffff').AndReturn({ 'router': { 'status': 'BUILD', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) neutronclient.Client.show_router('ffff').AndReturn({ 'router': { 'status': 'ACTIVE', 'name': self.rt_name, 'admin_state_up': True, 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'id': 'ffff' } }) self.mock_router_for_vpc() neutronclient.Client.add_gateway_router('ffff', { 'network_id': 'zzzz' }).AndReturn(None)
def test_create_failed_unexpected_vip_status(self): neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123' ).AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'SOMETHING', 'name': 'xyz'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) rsrc = loadbalancer.Pool( 'pool', resource_defns['pool'], stack) self.m.ReplayAll() error = self.assertRaises(exception.ResourceFailure, scheduler.TaskRunner(rsrc.create)) self.assertEqual('ResourceUnknownStatus: Pool creation failed due to ' 'vip - Unknown status SOMETHING due to "Unknown"', six.text_type(error)) self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state) self.m.VerifyAll()
def test_create_pool_with_provider(self): snippet = template_format.parse(pool_template_with_provider) self.stub_ProviderConstraint_validate() self.stack = utils.parse_stack(snippet) neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123', cmd_resource=None, ).MultipleTimes().AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName(self.stack.name, 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True, 'provider': 'test_prov'}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn( {'pool': {'status': 'ACTIVE', 'provider': 'test_prov'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) resource_defns = self.stack.t.resource_definitions(self.stack) rsrc = loadbalancer.Pool( 'pool', resource_defns['pool'], self.stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.assertEqual("test_prov", rsrc.FnGetAtt("provider")) self.m.VerifyAll()
def mock_show_security_group(self): sg_name = utils.PhysName('test_stack', 'the_sg') self._group = '0389f747-7785-4757-b7bb-2ab07e4b09c3' self.mockclient.show_security_group.return_value = { 'security_group': { 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'name': sg_name, 'description': '', 'security_group_rules': [{ 'direction': 'ingress', 'protocol': 'tcp', 'port_range_max': 22, 'id': 'bbbb', 'ethertype': 'IPv4', 'security_group_id': ('0389f747-7785-4757-b7bb-' '2ab07e4b09c3'), 'remote_group_id': None, 'remote_ip_prefix': '0.0.0.0/0', 'tenant_id': 'c1210485b2424d48804aad5d39c61b8f', 'port_range_min': 22 }], 'id': '0389f747-7785-4757-b7bb-2ab07e4b09c3' } }
def test_delete_non_empty_allowed(self, mock_put, mock_get, mock_delete_object, mock_delete_container): # Setup res_prop = self.t['Resources']['SwiftContainer']['Properties'] res_prop['PurgeOnDelete'] = True stack = utils.parse_stack(self.t) container_name = utils.PhysName(stack.name, 'test_resource') get_return_values = [ ({ 'name': container_name }, [{ 'name': 'test_object1' }, { 'name': 'test_object2' }]), ({ 'name': container_name }, [{ 'name': 'test_object1' }]), ] mock_get.side_effect = get_return_values # Test container = self._create_container(stack) runner = scheduler.TaskRunner(container.delete) runner() # Verify self.assertEqual((container.DELETE, container.COMPLETE), container.state) mock_put.assert_called_once_with(container_name, {}) mock_delete_container.assert_called_once_with(container_name) self.assertEqual(2, mock_get.call_count) self.assertEqual(2, mock_delete_object.call_count)
def test_create_pending(self): neutronV20.find_resourceid_by_name_or_id( mox.IsA(neutronclient.Client), 'subnet', 'sub123' ).AndReturn('sub123') neutronclient.Client.create_pool({ 'pool': { 'subnet_id': 'sub123', 'protocol': u'HTTP', 'name': utils.PhysName('test_stack', 'pool'), 'lb_method': 'ROUND_ROBIN', 'admin_state_up': True}} ).AndReturn({'pool': {'id': '5678'}}) neutronclient.Client.create_vip({ 'vip': { 'protocol': u'HTTP', 'name': 'pool.vip', 'admin_state_up': True, 'subnet_id': u'sub123', 'pool_id': '5678', 'protocol_port': 80}} ).AndReturn({'vip': {'id': 'xyz'}}) neutronclient.Client.show_pool('5678').AndReturn( {'pool': {'status': 'PENDING_CREATE'}}) neutronclient.Client.show_pool('5678').MultipleTimes().AndReturn( {'pool': {'status': 'ACTIVE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'PENDING_CREATE'}}) neutronclient.Client.show_vip('xyz').AndReturn( {'vip': {'status': 'ACTIVE'}}) snippet = template_format.parse(pool_template) stack = utils.parse_stack(snippet) resource_defns = stack.t.resource_definitions(stack) rsrc = loadbalancer.Pool( 'pool', resource_defns['pool'], stack) self.m.ReplayAll() scheduler.TaskRunner(rsrc.create)() self.assertEqual((rsrc.CREATE, rsrc.COMPLETE), rsrc.state) self.m.VerifyAll()
def test_security_groups(self): t = template_format.parse(neutron_port_template) t['resources']['port']['properties']['security_groups'] = [ '8a2f582a-e1cd-480f-b85d-b02631c10656', '024613dc-b489-4478-b46f-ada462738740' ] stack = utils.parse_stack(t) port_prop = { 'network_id': u'net_or_sub', 'security_groups': [ '8a2f582a-e1cd-480f-b85d-b02631c10656', '024613dc-b489-4478-b46f-ada462738740' ], 'fixed_ips': [{ 'subnet_id': u'net_or_sub', 'ip_address': u'10.0.3.21' }], 'name': utils.PhysName(stack.name, 'port'), 'admin_state_up': True, 'device_owner': u'network:dhcp', 'binding:vnic_type': 'normal', 'device_id': '' } self._mock_create_with_props() port = stack['port'] scheduler.TaskRunner(port.create)() self.assertEqual((port.CREATE, port.COMPLETE), port.state) self.create_mock.assert_called_once_with({'port': port_prop})
def _setup_test_group(self, intags=None, nova_tags=None): stack_name = 'tag_test' t = template_format.parse(group_template) template = parser.Template(t) stack = parser.Stack(utils.dummy_context(), stack_name, template, environment.Environment({'KeyName': 'test'}), stack_id=str(uuid.uuid4())) t['Resources']['WebServer']['Properties']['Tags'] = intags # create the launch configuration conf = stack['Config'] self.assertIsNone(conf.validate()) scheduler.TaskRunner(conf.create)() self.assertEqual((conf.CREATE, conf.COMPLETE), conf.state) group = stack['WebServer'] nova_tags['metering.groupname'] = utils.PhysName(stack.name, group.name) self.m.StubOutWithMock(instances.Instance, 'nova') instances.Instance.nova().MultipleTimes().AndReturn(self.fc) group.t = group.stack.resolve_runtime_data(group.t) # need to resolve the template functions self.m.StubOutWithMock(self.fc.servers, 'create') self.fc.servers.create( image=1, flavor=1, key_name='test', name=mox.IgnoreArg(), security_groups=None, userdata=mox.IgnoreArg(), scheduler_hints=None, meta=nova_tags, nics=None, availability_zone=None).AndReturn( self.fc.servers.list()[1]) return group