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
